H-Termination proof of /home/matraf/haskell/eval_FullyBlown

YES 10.054 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/empty.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:

↳ HASKELL

  ↳ IFR

mainModule Main

((gcd :: Int -> Int -> Int) :: Int -> Int -> Int)

module Main where

import qualified Prelude

If Reductions:
The following If expression

if primGEqNatS x y then primModNatS (primMinusNatS x y) (Succ y) else Succ x

is transformed to

primModNatS0 x y True = primModNatS (primMinusNatS x y) (Succ y)

primModNatS0 x y False = Succ x

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

mainModule Main

((gcd :: Int -> Int -> Int) :: Int -> Int -> Int)

module Main where

import qualified Prelude

Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

mainModule Main

((gcd :: Int -> Int -> Int) :: Int -> Int -> Int)

module Main where

import qualified Prelude

Cond Reductions:
The following Function with conditions

gcd' x 0 = x

gcd' x y = gcd' y (x `rem` y)

is transformed to

gcd' x xx = gcd'2 x xx

gcd' x y = gcd'0 x y

gcd'0 x y = gcd' y (x `rem` y)

gcd'1 True x xx = x

gcd'1 xy xz yu = gcd'0 xz yu

gcd'2 x xx = gcd'1 (xx == 0) x xx

gcd'2 yv yw = gcd'0 yv yw

The following Function with conditions

gcd 0 0 = error []

gcd x y =

gcd' (abs x) (abs y)

where

gcd' x 0 = x

gcd' x y = gcd' y (x `rem` y)

is transformed to

gcd yx yy = gcd3 yx yy

gcd x y = gcd0 x y

gcd0 x y =

gcd' (abs x) (abs y)

where

gcd' x xx = gcd'2 x xx

gcd' x y = gcd'0 x y

gcd'0 x y = gcd' y (x `rem` y)

gcd'1 True x xx = x

gcd'1 xy xz yu = gcd'0 xz yu

gcd'2 x xx = gcd'1 (xx == 0) x xx

gcd'2 yv yw = gcd'0 yv yw

gcd1 True yx yy = error []

gcd1 yz zu zv = gcd0 zu zv

gcd2 True yx yy = gcd1 (yy == 0) yx yy

gcd2 zw zx zy = gcd0 zx zy

gcd3 yx yy = gcd2 (yx == 0) yx yy

gcd3 zz vuu = gcd0 zz vuu

The following Function with conditions

absReal x

| x >= 0

= x

| otherwise

= `negate` x

is transformed to

absReal x = absReal2 x

absReal0 x True = `negate` x

absReal1 x True = x

absReal1 x False = absReal0 x otherwise

absReal2 x = absReal1 x (x >= 0)

The following Function with conditions

undefined

| False

= undefined

is transformed to

undefined = undefined1

undefined0 True = undefined

undefined1 = undefined0 False

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

mainModule Main

((gcd :: Int -> Int -> Int) :: Int -> Int -> Int)

module Main where

import qualified Prelude

Let/Where Reductions:
The bindings of the following Let/Where expression

gcd' (abs x) (abs y)

where

gcd' x xx = gcd'2 x xx

gcd' x y = gcd'0 x y

gcd'0 x y = gcd' y (x `rem` y)

gcd'1 True x xx = x

gcd'1 xy xz yu = gcd'0 xz yu

gcd'2 x xx = gcd'1 (xx == 0) x xx

gcd'2 yv yw = gcd'0 yv yw

are unpacked to the following functions on top level

gcd0Gcd' x xx = gcd0Gcd'2 x xx

gcd0Gcd' x y = gcd0Gcd'0 x y

gcd0Gcd'1 True x xx = x

gcd0Gcd'1 xy xz yu = gcd0Gcd'0 xz yu

gcd0Gcd'2 x xx = gcd0Gcd'1 (xx == 0) x xx

gcd0Gcd'2 yv yw = gcd0Gcd'0 yv yw

gcd0Gcd'0 x y = gcd0Gcd' y (x `rem` y)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

mainModule Main

((gcd :: Int -> Int -> Int) :: Int -> Int -> Int)

module Main where

import qualified Prelude

Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

mainModule Main

(gcd :: Int -> Int -> Int)

module Main where

import qualified Prelude

Haskell To QDPs

digraph dp_graph {
node [outthreshold=100, inthreshold=100];1[label="gcd",fontsize=16,color="grey",shape="box"];1 -> 3[label="",style="dashed", color="grey", weight=3];
3[label="gcd vuv3",fontsize=16,color="grey",shape="box"];3 -> 4[label="",style="dashed", color="grey", weight=3];
4[label="gcd vuv3 vuv4",fontsize=16,color="black",shape="triangle"];4 -> 5[label="",style="solid", color="black", weight=3];
5[label="gcd3 vuv3 vuv4",fontsize=16,color="black",shape="box"];5 -> 6[label="",style="solid", color="black", weight=3];
6[label="gcd2 (vuv3 == fromInt (Pos Zero)) vuv3 vuv4",fontsize=16,color="black",shape="box"];6 -> 7[label="",style="solid", color="black", weight=3];
7[label="gcd2 (primEqInt vuv3 (fromInt (Pos Zero))) vuv3 vuv4",fontsize=16,color="burlywood",shape="box"];1509[label="vuv3/Pos vuv30",fontsize=10,color="white",style="solid",shape="box"];7 -> 1509[label="",style="solid", color="burlywood", weight=9];
1509 -> 8[label="",style="solid", color="burlywood", weight=3];
1510[label="vuv3/Neg vuv30",fontsize=10,color="white",style="solid",shape="box"];7 -> 1510[label="",style="solid", color="burlywood", weight=9];
1510 -> 9[label="",style="solid", color="burlywood", weight=3];
8[label="gcd2 (primEqInt (Pos vuv30) (fromInt (Pos Zero))) (Pos vuv30) vuv4",fontsize=16,color="burlywood",shape="box"];1511[label="vuv30/Succ vuv300",fontsize=10,color="white",style="solid",shape="box"];8 -> 1511[label="",style="solid", color="burlywood", weight=9];
1511 -> 10[label="",style="solid", color="burlywood", weight=3];
1512[label="vuv30/Zero",fontsize=10,color="white",style="solid",shape="box"];8 -> 1512[label="",style="solid", color="burlywood", weight=9];
1512 -> 11[label="",style="solid", color="burlywood", weight=3];
9[label="gcd2 (primEqInt (Neg vuv30) (fromInt (Pos Zero))) (Neg vuv30) vuv4",fontsize=16,color="burlywood",shape="box"];1513[label="vuv30/Succ vuv300",fontsize=10,color="white",style="solid",shape="box"];9 -> 1513[label="",style="solid", color="burlywood", weight=9];
1513 -> 12[label="",style="solid", color="burlywood", weight=3];
1514[label="vuv30/Zero",fontsize=10,color="white",style="solid",shape="box"];9 -> 1514[label="",style="solid", color="burlywood", weight=9];
1514 -> 13[label="",style="solid", color="burlywood", weight=3];
10[label="gcd2 (primEqInt (Pos (Succ vuv300)) (fromInt (Pos Zero))) (Pos (Succ vuv300)) vuv4",fontsize=16,color="black",shape="box"];10 -> 14[label="",style="solid", color="black", weight=3];
11[label="gcd2 (primEqInt (Pos Zero) (fromInt (Pos Zero))) (Pos Zero) vuv4",fontsize=16,color="black",shape="box"];11 -> 15[label="",style="solid", color="black", weight=3];
12[label="gcd2 (primEqInt (Neg (Succ vuv300)) (fromInt (Pos Zero))) (Neg (Succ vuv300)) vuv4",fontsize=16,color="black",shape="box"];12 -> 16[label="",style="solid", color="black", weight=3];
13[label="gcd2 (primEqInt (Neg Zero) (fromInt (Pos Zero))) (Neg Zero) vuv4",fontsize=16,color="black",shape="box"];13 -> 17[label="",style="solid", color="black", weight=3];
14[label="gcd2 (primEqInt (Pos (Succ vuv300)) (Pos Zero)) (Pos (Succ vuv300)) vuv4",fontsize=16,color="black",shape="box"];14 -> 18[label="",style="solid", color="black", weight=3];
15[label="gcd2 (primEqInt (Pos Zero) (Pos Zero)) (Pos Zero) vuv4",fontsize=16,color="black",shape="box"];15 -> 19[label="",style="solid", color="black", weight=3];
16[label="gcd2 (primEqInt (Neg (Succ vuv300)) (Pos Zero)) (Neg (Succ vuv300)) vuv4",fontsize=16,color="black",shape="box"];16 -> 20[label="",style="solid", color="black", weight=3];
17[label="gcd2 (primEqInt (Neg Zero) (Pos Zero)) (Neg Zero) vuv4",fontsize=16,color="black",shape="box"];17 -> 21[label="",style="solid", color="black", weight=3];
18[label="gcd2 False (Pos (Succ vuv300)) vuv4",fontsize=16,color="black",shape="box"];18 -> 22[label="",style="solid", color="black", weight=3];
19[label="gcd2 True (Pos Zero) vuv4",fontsize=16,color="black",shape="box"];19 -> 23[label="",style="solid", color="black", weight=3];
20[label="gcd2 False (Neg (Succ vuv300)) vuv4",fontsize=16,color="black",shape="box"];20 -> 24[label="",style="solid", color="black", weight=3];
21[label="gcd2 True (Neg Zero) vuv4",fontsize=16,color="black",shape="box"];21 -> 25[label="",style="solid", color="black", weight=3];
22[label="gcd0 (Pos (Succ vuv300)) vuv4",fontsize=16,color="black",shape="box"];22 -> 26[label="",style="solid", color="black", weight=3];
23[label="gcd1 (vuv4 == fromInt (Pos Zero)) (Pos Zero) vuv4",fontsize=16,color="black",shape="box"];23 -> 27[label="",style="solid", color="black", weight=3];
24[label="gcd0 (Neg (Succ vuv300)) vuv4",fontsize=16,color="black",shape="box"];24 -> 28[label="",style="solid", color="black", weight=3];
25[label="gcd1 (vuv4 == fromInt (Pos Zero)) (Neg Zero) vuv4",fontsize=16,color="black",shape="box"];25 -> 29[label="",style="solid", color="black", weight=3];
26[label="gcd0Gcd' (abs (Pos (Succ vuv300))) (abs vuv4)",fontsize=16,color="black",shape="box"];26 -> 30[label="",style="solid", color="black", weight=3];
27[label="gcd1 (primEqInt vuv4 (fromInt (Pos Zero))) (Pos Zero) vuv4",fontsize=16,color="burlywood",shape="box"];1515[label="vuv4/Pos vuv40",fontsize=10,color="white",style="solid",shape="box"];27 -> 1515[label="",style="solid", color="burlywood", weight=9];
1515 -> 31[label="",style="solid", color="burlywood", weight=3];
1516[label="vuv4/Neg vuv40",fontsize=10,color="white",style="solid",shape="box"];27 -> 1516[label="",style="solid", color="burlywood", weight=9];
1516 -> 32[label="",style="solid", color="burlywood", weight=3];
28[label="gcd0Gcd' (abs (Neg (Succ vuv300))) (abs vuv4)",fontsize=16,color="black",shape="box"];28 -> 33[label="",style="solid", color="black", weight=3];
29[label="gcd1 (primEqInt vuv4 (fromInt (Pos Zero))) (Neg Zero) vuv4",fontsize=16,color="burlywood",shape="box"];1517[label="vuv4/Pos vuv40",fontsize=10,color="white",style="solid",shape="box"];29 -> 1517[label="",style="solid", color="burlywood", weight=9];
1517 -> 34[label="",style="solid", color="burlywood", weight=3];
1518[label="vuv4/Neg vuv40",fontsize=10,color="white",style="solid",shape="box"];29 -> 1518[label="",style="solid", color="burlywood", weight=9];
1518 -> 35[label="",style="solid", color="burlywood", weight=3];
30[label="gcd0Gcd'2 (abs (Pos (Succ vuv300))) (abs vuv4)",fontsize=16,color="black",shape="box"];30 -> 36[label="",style="solid", color="black", weight=3];
31[label="gcd1 (primEqInt (Pos vuv40) (fromInt (Pos Zero))) (Pos Zero) (Pos vuv40)",fontsize=16,color="burlywood",shape="box"];1519[label="vuv40/Succ vuv400",fontsize=10,color="white",style="solid",shape="box"];31 -> 1519[label="",style="solid", color="burlywood", weight=9];
1519 -> 37[label="",style="solid", color="burlywood", weight=3];
1520[label="vuv40/Zero",fontsize=10,color="white",style="solid",shape="box"];31 -> 1520[label="",style="solid", color="burlywood", weight=9];
1520 -> 38[label="",style="solid", color="burlywood", weight=3];
32[label="gcd1 (primEqInt (Neg vuv40) (fromInt (Pos Zero))) (Pos Zero) (Neg vuv40)",fontsize=16,color="burlywood",shape="box"];1521[label="vuv40/Succ vuv400",fontsize=10,color="white",style="solid",shape="box"];32 -> 1521[label="",style="solid", color="burlywood", weight=9];
1521 -> 39[label="",style="solid", color="burlywood", weight=3];
1522[label="vuv40/Zero",fontsize=10,color="white",style="solid",shape="box"];32 -> 1522[label="",style="solid", color="burlywood", weight=9];
1522 -> 40[label="",style="solid", color="burlywood", weight=3];
33[label="gcd0Gcd'2 (abs (Neg (Succ vuv300))) (abs vuv4)",fontsize=16,color="black",shape="box"];33 -> 41[label="",style="solid", color="black", weight=3];
34[label="gcd1 (primEqInt (Pos vuv40) (fromInt (Pos Zero))) (Neg Zero) (Pos vuv40)",fontsize=16,color="burlywood",shape="box"];1523[label="vuv40/Succ vuv400",fontsize=10,color="white",style="solid",shape="box"];34 -> 1523[label="",style="solid", color="burlywood", weight=9];
1523 -> 42[label="",style="solid", color="burlywood", weight=3];
1524[label="vuv40/Zero",fontsize=10,color="white",style="solid",shape="box"];34 -> 1524[label="",style="solid", color="burlywood", weight=9];
1524 -> 43[label="",style="solid", color="burlywood", weight=3];
35[label="gcd1 (primEqInt (Neg vuv40) (fromInt (Pos Zero))) (Neg Zero) (Neg vuv40)",fontsize=16,color="burlywood",shape="box"];1525[label="vuv40/Succ vuv400",fontsize=10,color="white",style="solid",shape="box"];35 -> 1525[label="",style="solid", color="burlywood", weight=9];
1525 -> 44[label="",style="solid", color="burlywood", weight=3];
1526[label="vuv40/Zero",fontsize=10,color="white",style="solid",shape="box"];35 -> 1526[label="",style="solid", color="burlywood", weight=9];
1526 -> 45[label="",style="solid", color="burlywood", weight=3];
36[label="gcd0Gcd'1 (abs vuv4 == fromInt (Pos Zero)) (abs (Pos (Succ vuv300))) (abs vuv4)",fontsize=16,color="black",shape="box"];36 -> 46[label="",style="solid", color="black", weight=3];
37[label="gcd1 (primEqInt (Pos (Succ vuv400)) (fromInt (Pos Zero))) (Pos Zero) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];37 -> 47[label="",style="solid", color="black", weight=3];
38[label="gcd1 (primEqInt (Pos Zero) (fromInt (Pos Zero))) (Pos Zero) (Pos Zero)",fontsize=16,color="black",shape="box"];38 -> 48[label="",style="solid", color="black", weight=3];
39[label="gcd1 (primEqInt (Neg (Succ vuv400)) (fromInt (Pos Zero))) (Pos Zero) (Neg (Succ vuv400))",fontsize=16,color="black",shape="box"];39 -> 49[label="",style="solid", color="black", weight=3];
40[label="gcd1 (primEqInt (Neg Zero) (fromInt (Pos Zero))) (Pos Zero) (Neg Zero)",fontsize=16,color="black",shape="box"];40 -> 50[label="",style="solid", color="black", weight=3];
41[label="gcd0Gcd'1 (abs vuv4 == fromInt (Pos Zero)) (abs (Neg (Succ vuv300))) (abs vuv4)",fontsize=16,color="black",shape="box"];41 -> 51[label="",style="solid", color="black", weight=3];
42[label="gcd1 (primEqInt (Pos (Succ vuv400)) (fromInt (Pos Zero))) (Neg Zero) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];42 -> 52[label="",style="solid", color="black", weight=3];
43[label="gcd1 (primEqInt (Pos Zero) (fromInt (Pos Zero))) (Neg Zero) (Pos Zero)",fontsize=16,color="black",shape="box"];43 -> 53[label="",style="solid", color="black", weight=3];
44[label="gcd1 (primEqInt (Neg (Succ vuv400)) (fromInt (Pos Zero))) (Neg Zero) (Neg (Succ vuv400))",fontsize=16,color="black",shape="box"];44 -> 54[label="",style="solid", color="black", weight=3];
45[label="gcd1 (primEqInt (Neg Zero) (fromInt (Pos Zero))) (Neg Zero) (Neg Zero)",fontsize=16,color="black",shape="box"];45 -> 55[label="",style="solid", color="black", weight=3];
46[label="gcd0Gcd'1 (primEqInt (abs vuv4) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (abs vuv4)",fontsize=16,color="black",shape="box"];46 -> 56[label="",style="solid", color="black", weight=3];
47[label="gcd1 (primEqInt (Pos (Succ vuv400)) (Pos Zero)) (Pos Zero) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];47 -> 57[label="",style="solid", color="black", weight=3];
48[label="gcd1 (primEqInt (Pos Zero) (Pos Zero)) (Pos Zero) (Pos Zero)",fontsize=16,color="black",shape="box"];48 -> 58[label="",style="solid", color="black", weight=3];
49[label="gcd1 (primEqInt (Neg (Succ vuv400)) (Pos Zero)) (Pos Zero) (Neg (Succ vuv400))",fontsize=16,color="black",shape="box"];49 -> 59[label="",style="solid", color="black", weight=3];
50[label="gcd1 (primEqInt (Neg Zero) (Pos Zero)) (Pos Zero) (Neg Zero)",fontsize=16,color="black",shape="box"];50 -> 60[label="",style="solid", color="black", weight=3];
51[label="gcd0Gcd'1 (primEqInt (abs vuv4) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (abs vuv4)",fontsize=16,color="black",shape="box"];51 -> 61[label="",style="solid", color="black", weight=3];
52[label="gcd1 (primEqInt (Pos (Succ vuv400)) (Pos Zero)) (Neg Zero) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];52 -> 62[label="",style="solid", color="black", weight=3];
53[label="gcd1 (primEqInt (Pos Zero) (Pos Zero)) (Neg Zero) (Pos Zero)",fontsize=16,color="black",shape="box"];53 -> 63[label="",style="solid", color="black", weight=3];
54[label="gcd1 (primEqInt (Neg (Succ vuv400)) (Pos Zero)) (Neg Zero) (Neg (Succ vuv400))",fontsize=16,color="black",shape="box"];54 -> 64[label="",style="solid", color="black", weight=3];
55[label="gcd1 (primEqInt (Neg Zero) (Pos Zero)) (Neg Zero) (Neg Zero)",fontsize=16,color="black",shape="box"];55 -> 65[label="",style="solid", color="black", weight=3];
56[label="gcd0Gcd'1 (primEqInt (absReal vuv4) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal vuv4)",fontsize=16,color="black",shape="box"];56 -> 66[label="",style="solid", color="black", weight=3];
57[label="gcd1 False (Pos Zero) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];57 -> 67[label="",style="solid", color="black", weight=3];
58[label="gcd1 True (Pos Zero) (Pos Zero)",fontsize=16,color="black",shape="box"];58 -> 68[label="",style="solid", color="black", weight=3];
59[label="gcd1 False (Pos Zero) (Neg (Succ vuv400))",fontsize=16,color="black",shape="box"];59 -> 69[label="",style="solid", color="black", weight=3];
60[label="gcd1 True (Pos Zero) (Neg Zero)",fontsize=16,color="black",shape="box"];60 -> 70[label="",style="solid", color="black", weight=3];
61[label="gcd0Gcd'1 (primEqInt (absReal vuv4) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal vuv4)",fontsize=16,color="black",shape="box"];61 -> 71[label="",style="solid", color="black", weight=3];
62[label="gcd1 False (Neg Zero) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];62 -> 72[label="",style="solid", color="black", weight=3];
63[label="gcd1 True (Neg Zero) (Pos Zero)",fontsize=16,color="black",shape="box"];63 -> 73[label="",style="solid", color="black", weight=3];
64[label="gcd1 False (Neg Zero) (Neg (Succ vuv400))",fontsize=16,color="black",shape="box"];64 -> 74[label="",style="solid", color="black", weight=3];
65[label="gcd1 True (Neg Zero) (Neg Zero)",fontsize=16,color="black",shape="box"];65 -> 75[label="",style="solid", color="black", weight=3];
66[label="gcd0Gcd'1 (primEqInt (absReal2 vuv4) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal2 vuv4)",fontsize=16,color="black",shape="box"];66 -> 76[label="",style="solid", color="black", weight=3];
67[label="gcd0 (Pos Zero) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];67 -> 77[label="",style="solid", color="black", weight=3];
68[label="error []",fontsize=16,color="black",shape="triangle"];68 -> 78[label="",style="solid", color="black", weight=3];
69[label="gcd0 (Pos Zero) (Neg (Succ vuv400))",fontsize=16,color="black",shape="box"];69 -> 79[label="",style="solid", color="black", weight=3];
70 -> 68[label="",style="dashed", color="red", weight=0];
70[label="error []",fontsize=16,color="magenta"];71[label="gcd0Gcd'1 (primEqInt (absReal2 vuv4) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal2 vuv4)",fontsize=16,color="black",shape="box"];71 -> 80[label="",style="solid", color="black", weight=3];
72[label="gcd0 (Neg Zero) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];72 -> 81[label="",style="solid", color="black", weight=3];
73 -> 68[label="",style="dashed", color="red", weight=0];
73[label="error []",fontsize=16,color="magenta"];74[label="gcd0 (Neg Zero) (Neg (Succ vuv400))",fontsize=16,color="black",shape="box"];74 -> 82[label="",style="solid", color="black", weight=3];
75 -> 68[label="",style="dashed", color="red", weight=0];
75[label="error []",fontsize=16,color="magenta"];76[label="gcd0Gcd'1 (primEqInt (absReal1 vuv4 (vuv4 >= fromInt (Pos Zero))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 vuv4 (vuv4 >= fromInt (Pos Zero)))",fontsize=16,color="black",shape="box"];76 -> 83[label="",style="solid", color="black", weight=3];
77[label="gcd0Gcd' (abs (Pos Zero)) (abs (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];77 -> 84[label="",style="solid", color="black", weight=3];
78[label="error []",fontsize=16,color="red",shape="box"];79[label="gcd0Gcd' (abs (Pos Zero)) (abs (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];79 -> 85[label="",style="solid", color="black", weight=3];
80[label="gcd0Gcd'1 (primEqInt (absReal1 vuv4 (vuv4 >= fromInt (Pos Zero))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 vuv4 (vuv4 >= fromInt (Pos Zero)))",fontsize=16,color="black",shape="box"];80 -> 86[label="",style="solid", color="black", weight=3];
81[label="gcd0Gcd' (abs (Neg Zero)) (abs (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];81 -> 87[label="",style="solid", color="black", weight=3];
82[label="gcd0Gcd' (abs (Neg Zero)) (abs (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];82 -> 88[label="",style="solid", color="black", weight=3];
83[label="gcd0Gcd'1 (primEqInt (absReal1 vuv4 (compare vuv4 (fromInt (Pos Zero)) /= LT)) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 vuv4 (compare vuv4 (fromInt (Pos Zero)) /= LT))",fontsize=16,color="black",shape="box"];83 -> 89[label="",style="solid", color="black", weight=3];
84[label="gcd0Gcd'2 (abs (Pos Zero)) (abs (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];84 -> 90[label="",style="solid", color="black", weight=3];
85[label="gcd0Gcd'2 (abs (Pos Zero)) (abs (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];85 -> 91[label="",style="solid", color="black", weight=3];
86[label="gcd0Gcd'1 (primEqInt (absReal1 vuv4 (compare vuv4 (fromInt (Pos Zero)) /= LT)) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 vuv4 (compare vuv4 (fromInt (Pos Zero)) /= LT))",fontsize=16,color="black",shape="box"];86 -> 92[label="",style="solid", color="black", weight=3];
87[label="gcd0Gcd'2 (abs (Neg Zero)) (abs (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];87 -> 93[label="",style="solid", color="black", weight=3];
88[label="gcd0Gcd'2 (abs (Neg Zero)) (abs (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];88 -> 94[label="",style="solid", color="black", weight=3];
89[label="gcd0Gcd'1 (primEqInt (absReal1 vuv4 (not (compare vuv4 (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 vuv4 (not (compare vuv4 (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];89 -> 95[label="",style="solid", color="black", weight=3];
90[label="gcd0Gcd'1 (abs (Pos (Succ vuv400)) == fromInt (Pos Zero)) (abs (Pos Zero)) (abs (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];90 -> 96[label="",style="solid", color="black", weight=3];
91[label="gcd0Gcd'1 (abs (Neg (Succ vuv400)) == fromInt (Pos Zero)) (abs (Pos Zero)) (abs (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];91 -> 97[label="",style="solid", color="black", weight=3];
92[label="gcd0Gcd'1 (primEqInt (absReal1 vuv4 (not (compare vuv4 (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 vuv4 (not (compare vuv4 (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];92 -> 98[label="",style="solid", color="black", weight=3];
93[label="gcd0Gcd'1 (abs (Pos (Succ vuv400)) == fromInt (Pos Zero)) (abs (Neg Zero)) (abs (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];93 -> 99[label="",style="solid", color="black", weight=3];
94[label="gcd0Gcd'1 (abs (Neg (Succ vuv400)) == fromInt (Pos Zero)) (abs (Neg Zero)) (abs (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];94 -> 100[label="",style="solid", color="black", weight=3];
95[label="gcd0Gcd'1 (primEqInt (absReal1 vuv4 (not (primCmpInt vuv4 (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 vuv4 (not (primCmpInt vuv4 (fromInt (Pos Zero)) == LT)))",fontsize=16,color="burlywood",shape="box"];1530[label="vuv4/Pos vuv40",fontsize=10,color="white",style="solid",shape="box"];95 -> 1530[label="",style="solid", color="burlywood", weight=9];
1530 -> 101[label="",style="solid", color="burlywood", weight=3];
1531[label="vuv4/Neg vuv40",fontsize=10,color="white",style="solid",shape="box"];95 -> 1531[label="",style="solid", color="burlywood", weight=9];
1531 -> 102[label="",style="solid", color="burlywood", weight=3];
96[label="gcd0Gcd'1 (primEqInt (abs (Pos (Succ vuv400))) (fromInt (Pos Zero))) (abs (Pos Zero)) (abs (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];96 -> 103[label="",style="solid", color="black", weight=3];
97[label="gcd0Gcd'1 (primEqInt (abs (Neg (Succ vuv400))) (fromInt (Pos Zero))) (abs (Pos Zero)) (abs (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];97 -> 104[label="",style="solid", color="black", weight=3];
98[label="gcd0Gcd'1 (primEqInt (absReal1 vuv4 (not (primCmpInt vuv4 (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 vuv4 (not (primCmpInt vuv4 (fromInt (Pos Zero)) == LT)))",fontsize=16,color="burlywood",shape="box"];1532[label="vuv4/Pos vuv40",fontsize=10,color="white",style="solid",shape="box"];98 -> 1532[label="",style="solid", color="burlywood", weight=9];
1532 -> 105[label="",style="solid", color="burlywood", weight=3];
1533[label="vuv4/Neg vuv40",fontsize=10,color="white",style="solid",shape="box"];98 -> 1533[label="",style="solid", color="burlywood", weight=9];
1533 -> 106[label="",style="solid", color="burlywood", weight=3];
99[label="gcd0Gcd'1 (primEqInt (abs (Pos (Succ vuv400))) (fromInt (Pos Zero))) (abs (Neg Zero)) (abs (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];99 -> 107[label="",style="solid", color="black", weight=3];
100[label="gcd0Gcd'1 (primEqInt (abs (Neg (Succ vuv400))) (fromInt (Pos Zero))) (abs (Neg Zero)) (abs (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];100 -> 108[label="",style="solid", color="black", weight=3];
101[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos vuv40) (not (primCmpInt (Pos vuv40) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos vuv40) (not (primCmpInt (Pos vuv40) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="burlywood",shape="box"];1534[label="vuv40/Succ vuv400",fontsize=10,color="white",style="solid",shape="box"];101 -> 1534[label="",style="solid", color="burlywood", weight=9];
1534 -> 109[label="",style="solid", color="burlywood", weight=3];
1535[label="vuv40/Zero",fontsize=10,color="white",style="solid",shape="box"];101 -> 1535[label="",style="solid", color="burlywood", weight=9];
1535 -> 110[label="",style="solid", color="burlywood", weight=3];
102[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg vuv40) (not (primCmpInt (Neg vuv40) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg vuv40) (not (primCmpInt (Neg vuv40) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="burlywood",shape="box"];1536[label="vuv40/Succ vuv400",fontsize=10,color="white",style="solid",shape="box"];102 -> 1536[label="",style="solid", color="burlywood", weight=9];
1536 -> 111[label="",style="solid", color="burlywood", weight=3];
1537[label="vuv40/Zero",fontsize=10,color="white",style="solid",shape="box"];102 -> 1537[label="",style="solid", color="burlywood", weight=9];
1537 -> 112[label="",style="solid", color="burlywood", weight=3];
103[label="gcd0Gcd'1 (primEqInt (absReal (Pos (Succ vuv400))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];103 -> 113[label="",style="solid", color="black", weight=3];
104[label="gcd0Gcd'1 (primEqInt (absReal (Neg (Succ vuv400))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];104 -> 114[label="",style="solid", color="black", weight=3];
105[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos vuv40) (not (primCmpInt (Pos vuv40) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos vuv40) (not (primCmpInt (Pos vuv40) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="burlywood",shape="box"];1538[label="vuv40/Succ vuv400",fontsize=10,color="white",style="solid",shape="box"];105 -> 1538[label="",style="solid", color="burlywood", weight=9];
1538 -> 115[label="",style="solid", color="burlywood", weight=3];
1539[label="vuv40/Zero",fontsize=10,color="white",style="solid",shape="box"];105 -> 1539[label="",style="solid", color="burlywood", weight=9];
1539 -> 116[label="",style="solid", color="burlywood", weight=3];
106[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg vuv40) (not (primCmpInt (Neg vuv40) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg vuv40) (not (primCmpInt (Neg vuv40) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="burlywood",shape="box"];1540[label="vuv40/Succ vuv400",fontsize=10,color="white",style="solid",shape="box"];106 -> 1540[label="",style="solid", color="burlywood", weight=9];
1540 -> 117[label="",style="solid", color="burlywood", weight=3];
1541[label="vuv40/Zero",fontsize=10,color="white",style="solid",shape="box"];106 -> 1541[label="",style="solid", color="burlywood", weight=9];
1541 -> 118[label="",style="solid", color="burlywood", weight=3];
107[label="gcd0Gcd'1 (primEqInt (absReal (Pos (Succ vuv400))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];107 -> 119[label="",style="solid", color="black", weight=3];
108[label="gcd0Gcd'1 (primEqInt (absReal (Neg (Succ vuv400))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];108 -> 120[label="",style="solid", color="black", weight=3];
109[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];109 -> 121[label="",style="solid", color="black", weight=3];
110[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];110 -> 122[label="",style="solid", color="black", weight=3];
111[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];111 -> 123[label="",style="solid", color="black", weight=3];
112[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];112 -> 124[label="",style="solid", color="black", weight=3];
113[label="gcd0Gcd'1 (primEqInt (absReal2 (Pos (Succ vuv400))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal2 (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];113 -> 125[label="",style="solid", color="black", weight=3];
114[label="gcd0Gcd'1 (primEqInt (absReal2 (Neg (Succ vuv400))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal2 (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];114 -> 126[label="",style="solid", color="black", weight=3];
115[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];115 -> 127[label="",style="solid", color="black", weight=3];
116[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];116 -> 128[label="",style="solid", color="black", weight=3];
117[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];117 -> 129[label="",style="solid", color="black", weight=3];
118[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];118 -> 130[label="",style="solid", color="black", weight=3];
119[label="gcd0Gcd'1 (primEqInt (absReal2 (Pos (Succ vuv400))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal2 (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];119 -> 131[label="",style="solid", color="black", weight=3];
120[label="gcd0Gcd'1 (primEqInt (absReal2 (Neg (Succ vuv400))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal2 (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];120 -> 132[label="",style="solid", color="black", weight=3];
121[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];121 -> 133[label="",style="solid", color="black", weight=3];
122[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];122 -> 134[label="",style="solid", color="black", weight=3];
123[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];123 -> 135[label="",style="solid", color="black", weight=3];
124[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];124 -> 136[label="",style="solid", color="black", weight=3];
125[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (Pos (Succ vuv400) >= fromInt (Pos Zero))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) (Pos (Succ vuv400) >= fromInt (Pos Zero)))",fontsize=16,color="black",shape="box"];125 -> 137[label="",style="solid", color="black", weight=3];
126[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (Neg (Succ vuv400) >= fromInt (Pos Zero))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Neg (Succ vuv400)) (Neg (Succ vuv400) >= fromInt (Pos Zero)))",fontsize=16,color="black",shape="box"];126 -> 138[label="",style="solid", color="black", weight=3];
127[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];127 -> 139[label="",style="solid", color="black", weight=3];
128[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];128 -> 140[label="",style="solid", color="black", weight=3];
129[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];129 -> 141[label="",style="solid", color="black", weight=3];
130[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];130 -> 142[label="",style="solid", color="black", weight=3];
131[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (Pos (Succ vuv400) >= fromInt (Pos Zero))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) (Pos (Succ vuv400) >= fromInt (Pos Zero)))",fontsize=16,color="black",shape="box"];131 -> 143[label="",style="solid", color="black", weight=3];
132[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (Neg (Succ vuv400) >= fromInt (Pos Zero))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Neg (Succ vuv400)) (Neg (Succ vuv400) >= fromInt (Pos Zero)))",fontsize=16,color="black",shape="box"];132 -> 144[label="",style="solid", color="black", weight=3];
133[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpNat (Succ vuv400) Zero == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not (primCmpNat (Succ vuv400) Zero == LT)))",fontsize=16,color="black",shape="box"];133 -> 145[label="",style="solid", color="black", weight=3];
134[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) (not (EQ == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos Zero) (not (EQ == LT)))",fontsize=16,color="black",shape="box"];134 -> 146[label="",style="solid", color="black", weight=3];
135[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (LT == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) (not (LT == LT)))",fontsize=16,color="black",shape="box"];135 -> 147[label="",style="solid", color="black", weight=3];
136[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) (not (EQ == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg Zero) (not (EQ == LT)))",fontsize=16,color="black",shape="box"];136 -> 148[label="",style="solid", color="black", weight=3];
137[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (compare (Pos (Succ vuv400)) (fromInt (Pos Zero)) /= LT)) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) (compare (Pos (Succ vuv400)) (fromInt (Pos Zero)) /= LT))",fontsize=16,color="black",shape="box"];137 -> 149[label="",style="solid", color="black", weight=3];
138[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (compare (Neg (Succ vuv400)) (fromInt (Pos Zero)) /= LT)) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Neg (Succ vuv400)) (compare (Neg (Succ vuv400)) (fromInt (Pos Zero)) /= LT))",fontsize=16,color="black",shape="box"];138 -> 150[label="",style="solid", color="black", weight=3];
139[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpNat (Succ vuv400) Zero == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not (primCmpNat (Succ vuv400) Zero == LT)))",fontsize=16,color="black",shape="box"];139 -> 151[label="",style="solid", color="black", weight=3];
140[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) (not (EQ == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos Zero) (not (EQ == LT)))",fontsize=16,color="black",shape="box"];140 -> 152[label="",style="solid", color="black", weight=3];
141[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (LT == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) (not (LT == LT)))",fontsize=16,color="black",shape="box"];141 -> 153[label="",style="solid", color="black", weight=3];
142[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) (not (EQ == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg Zero) (not (EQ == LT)))",fontsize=16,color="black",shape="box"];142 -> 154[label="",style="solid", color="black", weight=3];
143[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (compare (Pos (Succ vuv400)) (fromInt (Pos Zero)) /= LT)) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) (compare (Pos (Succ vuv400)) (fromInt (Pos Zero)) /= LT))",fontsize=16,color="black",shape="box"];143 -> 155[label="",style="solid", color="black", weight=3];
144[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (compare (Neg (Succ vuv400)) (fromInt (Pos Zero)) /= LT)) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Neg (Succ vuv400)) (compare (Neg (Succ vuv400)) (fromInt (Pos Zero)) /= LT))",fontsize=16,color="black",shape="box"];144 -> 156[label="",style="solid", color="black", weight=3];
145[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (GT == LT))) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not (GT == LT)))",fontsize=16,color="black",shape="box"];145 -> 157[label="",style="solid", color="black", weight=3];
146[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) (not False)) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos Zero) (not False))",fontsize=16,color="black",shape="box"];146 -> 158[label="",style="solid", color="black", weight=3];
147[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not True)) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) (not True))",fontsize=16,color="black",shape="box"];147 -> 159[label="",style="solid", color="black", weight=3];
148[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) (not False)) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg Zero) (not False))",fontsize=16,color="black",shape="box"];148 -> 160[label="",style="solid", color="black", weight=3];
149[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (compare (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) (not (compare (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];149 -> 161[label="",style="solid", color="black", weight=3];
150[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (compare (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Neg (Succ vuv400)) (not (compare (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];150 -> 162[label="",style="solid", color="black", weight=3];
151[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (GT == LT))) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not (GT == LT)))",fontsize=16,color="black",shape="box"];151 -> 163[label="",style="solid", color="black", weight=3];
152[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) (not False)) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos Zero) (not False))",fontsize=16,color="black",shape="box"];152 -> 164[label="",style="solid", color="black", weight=3];
153[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not True)) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) (not True))",fontsize=16,color="black",shape="box"];153 -> 165[label="",style="solid", color="black", weight=3];
154[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) (not False)) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg Zero) (not False))",fontsize=16,color="black",shape="box"];154 -> 166[label="",style="solid", color="black", weight=3];
155[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (compare (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) (not (compare (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];155 -> 167[label="",style="solid", color="black", weight=3];
156[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (compare (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Neg (Succ vuv400)) (not (compare (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];156 -> 168[label="",style="solid", color="black", weight=3];
157[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not False)) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not False))",fontsize=16,color="black",shape="box"];157 -> 169[label="",style="solid", color="black", weight=3];
158[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) True) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos Zero) True)",fontsize=16,color="black",shape="box"];158 -> 170[label="",style="solid", color="black", weight=3];
159[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) False) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) False)",fontsize=16,color="black",shape="box"];159 -> 171[label="",style="solid", color="black", weight=3];
160[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) True) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Neg Zero) True)",fontsize=16,color="black",shape="box"];160 -> 172[label="",style="solid", color="black", weight=3];
161[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];161 -> 173[label="",style="solid", color="black", weight=3];
162[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];162 -> 174[label="",style="solid", color="black", weight=3];
163[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not False)) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) (not False))",fontsize=16,color="black",shape="box"];163 -> 175[label="",style="solid", color="black", weight=3];
164[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos Zero) True) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos Zero) True)",fontsize=16,color="black",shape="box"];164 -> 176[label="",style="solid", color="black", weight=3];
165[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) False) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg (Succ vuv400)) False)",fontsize=16,color="black",shape="box"];165 -> 177[label="",style="solid", color="black", weight=3];
166[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg Zero) True) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Neg Zero) True)",fontsize=16,color="black",shape="box"];166 -> 178[label="",style="solid", color="black", weight=3];
167[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];167 -> 179[label="",style="solid", color="black", weight=3];
168[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (fromInt (Pos Zero)) == LT)))",fontsize=16,color="black",shape="box"];168 -> 180[label="",style="solid", color="black", weight=3];
169[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) True) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) True)",fontsize=16,color="black",shape="box"];169 -> 181[label="",style="solid", color="black", weight=3];
170[label="gcd0Gcd'1 (primEqInt (Pos Zero) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (Pos Zero)",fontsize=16,color="black",shape="box"];170 -> 182[label="",style="solid", color="black", weight=3];
171[label="gcd0Gcd'1 (primEqInt (absReal0 (Neg (Succ vuv400)) otherwise) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal0 (Neg (Succ vuv400)) otherwise)",fontsize=16,color="black",shape="box"];171 -> 183[label="",style="solid", color="black", weight=3];
172[label="gcd0Gcd'1 (primEqInt (Neg Zero) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (Neg Zero)",fontsize=16,color="black",shape="box"];172 -> 184[label="",style="solid", color="black", weight=3];
173[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];173 -> 185[label="",style="solid", color="black", weight=3];
174[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];174 -> 186[label="",style="solid", color="black", weight=3];
175[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) True) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal1 (Pos (Succ vuv400)) True)",fontsize=16,color="black",shape="box"];175 -> 187[label="",style="solid", color="black", weight=3];
176[label="gcd0Gcd'1 (primEqInt (Pos Zero) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (Pos Zero)",fontsize=16,color="black",shape="box"];176 -> 188[label="",style="solid", color="black", weight=3];
177[label="gcd0Gcd'1 (primEqInt (absReal0 (Neg (Succ vuv400)) otherwise) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal0 (Neg (Succ vuv400)) otherwise)",fontsize=16,color="black",shape="box"];177 -> 189[label="",style="solid", color="black", weight=3];
178[label="gcd0Gcd'1 (primEqInt (Neg Zero) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (Neg Zero)",fontsize=16,color="black",shape="box"];178 -> 190[label="",style="solid", color="black", weight=3];
179[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) (not (primCmpInt (Pos (Succ vuv400)) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];179 -> 191[label="",style="solid", color="black", weight=3];
180[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (Pos Zero) == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Neg (Succ vuv400)) (not (primCmpInt (Neg (Succ vuv400)) (Pos Zero) == LT)))",fontsize=16,color="black",shape="box"];180 -> 192[label="",style="solid", color="black", weight=3];
181[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];181 -> 193[label="",style="solid", color="black", weight=3];
182[label="gcd0Gcd'1 (primEqInt (Pos Zero) (Pos Zero)) (abs (Pos (Succ vuv300))) (Pos Zero)",fontsize=16,color="black",shape="box"];182 -> 194[label="",style="solid", color="black", weight=3];
183[label="gcd0Gcd'1 (primEqInt (absReal0 (Neg (Succ vuv400)) True) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (absReal0 (Neg (Succ vuv400)) True)",fontsize=16,color="black",shape="box"];183 -> 195[label="",style="solid", color="black", weight=3];
184[label="gcd0Gcd'1 (primEqInt (Neg Zero) (Pos Zero)) (abs (Pos (Succ vuv300))) (Neg Zero)",fontsize=16,color="black",shape="box"];184 -> 196[label="",style="solid", color="black", weight=3];
185[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpNat (Succ vuv400) Zero == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) (not (primCmpNat (Succ vuv400) Zero == LT)))",fontsize=16,color="black",shape="box"];185 -> 197[label="",style="solid", color="black", weight=3];
186[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (LT == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Neg (Succ vuv400)) (not (LT == LT)))",fontsize=16,color="black",shape="box"];186 -> 198[label="",style="solid", color="black", weight=3];
187[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];187 -> 199[label="",style="solid", color="black", weight=3];
188[label="gcd0Gcd'1 (primEqInt (Pos Zero) (Pos Zero)) (abs (Neg (Succ vuv300))) (Pos Zero)",fontsize=16,color="black",shape="box"];188 -> 200[label="",style="solid", color="black", weight=3];
189[label="gcd0Gcd'1 (primEqInt (absReal0 (Neg (Succ vuv400)) True) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (absReal0 (Neg (Succ vuv400)) True)",fontsize=16,color="black",shape="box"];189 -> 201[label="",style="solid", color="black", weight=3];
190[label="gcd0Gcd'1 (primEqInt (Neg Zero) (Pos Zero)) (abs (Neg (Succ vuv300))) (Neg Zero)",fontsize=16,color="black",shape="box"];190 -> 202[label="",style="solid", color="black", weight=3];
191[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (primCmpNat (Succ vuv400) Zero == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) (not (primCmpNat (Succ vuv400) Zero == LT)))",fontsize=16,color="black",shape="box"];191 -> 203[label="",style="solid", color="black", weight=3];
192[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not (LT == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Neg (Succ vuv400)) (not (LT == LT)))",fontsize=16,color="black",shape="box"];192 -> 204[label="",style="solid", color="black", weight=3];
193[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (Pos Zero)) (abs (Pos (Succ vuv300))) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];193 -> 205[label="",style="solid", color="black", weight=3];
194[label="gcd0Gcd'1 True (abs (Pos (Succ vuv300))) (Pos Zero)",fontsize=16,color="black",shape="box"];194 -> 206[label="",style="solid", color="black", weight=3];
195 -> 252[label="",style="dashed", color="red", weight=0];
195[label="gcd0Gcd'1 (primEqInt (`negate` Neg (Succ vuv400)) (fromInt (Pos Zero))) (abs (Pos (Succ vuv300))) (`negate` Neg (Succ vuv400))",fontsize=16,color="magenta"];195 -> 253[label="",style="dashed", color="magenta", weight=3];
196[label="gcd0Gcd'1 True (abs (Pos (Succ vuv300))) (Neg Zero)",fontsize=16,color="black",shape="box"];196 -> 208[label="",style="solid", color="black", weight=3];
197[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (GT == LT))) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) (not (GT == LT)))",fontsize=16,color="black",shape="box"];197 -> 209[label="",style="solid", color="black", weight=3];
198[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not True)) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Neg (Succ vuv400)) (not True))",fontsize=16,color="black",shape="box"];198 -> 210[label="",style="solid", color="black", weight=3];
199[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (Pos Zero)) (abs (Neg (Succ vuv300))) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];199 -> 211[label="",style="solid", color="black", weight=3];
200[label="gcd0Gcd'1 True (abs (Neg (Succ vuv300))) (Pos Zero)",fontsize=16,color="black",shape="box"];200 -> 212[label="",style="solid", color="black", weight=3];
201 -> 252[label="",style="dashed", color="red", weight=0];
201[label="gcd0Gcd'1 (primEqInt (`negate` Neg (Succ vuv400)) (fromInt (Pos Zero))) (abs (Neg (Succ vuv300))) (`negate` Neg (Succ vuv400))",fontsize=16,color="magenta"];201 -> 254[label="",style="dashed", color="magenta", weight=3];
202[label="gcd0Gcd'1 True (abs (Neg (Succ vuv300))) (Neg Zero)",fontsize=16,color="black",shape="box"];202 -> 214[label="",style="solid", color="black", weight=3];
203[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not (GT == LT))) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) (not (GT == LT)))",fontsize=16,color="black",shape="box"];203 -> 215[label="",style="solid", color="black", weight=3];
204[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) (not True)) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Neg (Succ vuv400)) (not True))",fontsize=16,color="black",shape="box"];204 -> 216[label="",style="solid", color="black", weight=3];
205[label="gcd0Gcd'1 False (abs (Pos (Succ vuv300))) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];205 -> 217[label="",style="solid", color="black", weight=3];
206[label="abs (Pos (Succ vuv300))",fontsize=16,color="black",shape="triangle"];206 -> 218[label="",style="solid", color="black", weight=3];
253 -> 206[label="",style="dashed", color="red", weight=0];
253[label="abs (Pos (Succ vuv300))",fontsize=16,color="magenta"];252[label="gcd0Gcd'1 (primEqInt (`negate` Neg (Succ vuv400)) (fromInt (Pos Zero))) vuv7 (`negate` Neg (Succ vuv400))",fontsize=16,color="black",shape="triangle"];252 -> 257[label="",style="solid", color="black", weight=3];
208 -> 206[label="",style="dashed", color="red", weight=0];
208[label="abs (Pos (Succ vuv300))",fontsize=16,color="magenta"];209[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not False)) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) (not False))",fontsize=16,color="black",shape="box"];209 -> 222[label="",style="solid", color="black", weight=3];
210[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) False) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Neg (Succ vuv400)) False)",fontsize=16,color="black",shape="box"];210 -> 223[label="",style="solid", color="black", weight=3];
211[label="gcd0Gcd'1 False (abs (Neg (Succ vuv300))) (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];211 -> 224[label="",style="solid", color="black", weight=3];
212[label="abs (Neg (Succ vuv300))",fontsize=16,color="black",shape="triangle"];212 -> 225[label="",style="solid", color="black", weight=3];
254 -> 212[label="",style="dashed", color="red", weight=0];
254[label="abs (Neg (Succ vuv300))",fontsize=16,color="magenta"];214 -> 212[label="",style="dashed", color="red", weight=0];
214[label="abs (Neg (Succ vuv300))",fontsize=16,color="magenta"];215[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) (not False)) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) (not False))",fontsize=16,color="black",shape="box"];215 -> 226[label="",style="solid", color="black", weight=3];
216[label="gcd0Gcd'1 (primEqInt (absReal1 (Neg (Succ vuv400)) False) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Neg (Succ vuv400)) False)",fontsize=16,color="black",shape="box"];216 -> 227[label="",style="solid", color="black", weight=3];
217 -> 228[label="",style="dashed", color="red", weight=0];
217[label="gcd0Gcd'0 (abs (Pos (Succ vuv300))) (Pos (Succ vuv400))",fontsize=16,color="magenta"];217 -> 229[label="",style="dashed", color="magenta", weight=3];
218[label="absReal (Pos (Succ vuv300))",fontsize=16,color="black",shape="box"];218 -> 231[label="",style="solid", color="black", weight=3];
257[label="gcd0Gcd'1 (primEqInt (primNegInt (Neg (Succ vuv400))) (fromInt (Pos Zero))) vuv7 (primNegInt (Neg (Succ vuv400)))",fontsize=16,color="black",shape="box"];257 -> 264[label="",style="solid", color="black", weight=3];
222[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) True) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal1 (Pos (Succ vuv400)) True)",fontsize=16,color="black",shape="box"];222 -> 233[label="",style="solid", color="black", weight=3];
223[label="gcd0Gcd'1 (primEqInt (absReal0 (Neg (Succ vuv400)) otherwise) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal0 (Neg (Succ vuv400)) otherwise)",fontsize=16,color="black",shape="box"];223 -> 234[label="",style="solid", color="black", weight=3];
224 -> 228[label="",style="dashed", color="red", weight=0];
224[label="gcd0Gcd'0 (abs (Neg (Succ vuv300))) (Pos (Succ vuv400))",fontsize=16,color="magenta"];224 -> 230[label="",style="dashed", color="magenta", weight=3];
225[label="absReal (Neg (Succ vuv300))",fontsize=16,color="black",shape="box"];225 -> 235[label="",style="solid", color="black", weight=3];
226[label="gcd0Gcd'1 (primEqInt (absReal1 (Pos (Succ vuv400)) True) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal1 (Pos (Succ vuv400)) True)",fontsize=16,color="black",shape="box"];226 -> 236[label="",style="solid", color="black", weight=3];
227[label="gcd0Gcd'1 (primEqInt (absReal0 (Neg (Succ vuv400)) otherwise) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal0 (Neg (Succ vuv400)) otherwise)",fontsize=16,color="black",shape="box"];227 -> 237[label="",style="solid", color="black", weight=3];
229 -> 206[label="",style="dashed", color="red", weight=0];
229[label="abs (Pos (Succ vuv300))",fontsize=16,color="magenta"];228[label="gcd0Gcd'0 vuv6 (Pos (Succ vuv400))",fontsize=16,color="black",shape="triangle"];228 -> 238[label="",style="solid", color="black", weight=3];
231[label="absReal2 (Pos (Succ vuv300))",fontsize=16,color="black",shape="box"];231 -> 239[label="",style="solid", color="black", weight=3];
264 -> 232[label="",style="dashed", color="red", weight=0];
264[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (fromInt (Pos Zero))) vuv7 (Pos (Succ vuv400))",fontsize=16,color="magenta"];264 -> 272[label="",style="dashed", color="magenta", weight=3];
233 -> 232[label="",style="dashed", color="red", weight=0];
233[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (fromInt (Pos Zero))) (abs (Pos Zero)) (Pos (Succ vuv400))",fontsize=16,color="magenta"];233 -> 241[label="",style="dashed", color="magenta", weight=3];
233 -> 242[label="",style="dashed", color="magenta", weight=3];
234[label="gcd0Gcd'1 (primEqInt (absReal0 (Neg (Succ vuv400)) True) (fromInt (Pos Zero))) (abs (Pos Zero)) (absReal0 (Neg (Succ vuv400)) True)",fontsize=16,color="black",shape="box"];234 -> 243[label="",style="solid", color="black", weight=3];
230 -> 212[label="",style="dashed", color="red", weight=0];
230[label="abs (Neg (Succ vuv300))",fontsize=16,color="magenta"];235[label="absReal2 (Neg (Succ vuv300))",fontsize=16,color="black",shape="box"];235 -> 244[label="",style="solid", color="black", weight=3];
236 -> 232[label="",style="dashed", color="red", weight=0];
236[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (fromInt (Pos Zero))) (abs (Neg Zero)) (Pos (Succ vuv400))",fontsize=16,color="magenta"];236 -> 245[label="",style="dashed", color="magenta", weight=3];
236 -> 246[label="",style="dashed", color="magenta", weight=3];
237[label="gcd0Gcd'1 (primEqInt (absReal0 (Neg (Succ vuv400)) True) (fromInt (Pos Zero))) (abs (Neg Zero)) (absReal0 (Neg (Succ vuv400)) True)",fontsize=16,color="black",shape="box"];237 -> 247[label="",style="solid", color="black", weight=3];
238[label="gcd0Gcd' (Pos (Succ vuv400)) (vuv6 `rem` Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];238 -> 248[label="",style="solid", color="black", weight=3];
239[label="absReal1 (Pos (Succ vuv300)) (Pos (Succ vuv300) >= fromInt (Pos Zero))",fontsize=16,color="black",shape="box"];239 -> 249[label="",style="solid", color="black", weight=3];
272[label="vuv7",fontsize=16,color="green",shape="box"];232[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (fromInt (Pos Zero))) vuv5 (Pos (Succ vuv400))",fontsize=16,color="black",shape="triangle"];232 -> 240[label="",style="solid", color="black", weight=3];
241[label="vuv400",fontsize=16,color="green",shape="box"];242[label="abs (Pos Zero)",fontsize=16,color="black",shape="triangle"];242 -> 251[label="",style="solid", color="black", weight=3];
243 -> 252[label="",style="dashed", color="red", weight=0];
243[label="gcd0Gcd'1 (primEqInt (`negate` Neg (Succ vuv400)) (fromInt (Pos Zero))) (abs (Pos Zero)) (`negate` Neg (Succ vuv400))",fontsize=16,color="magenta"];243 -> 255[label="",style="dashed", color="magenta", weight=3];
244[label="absReal1 (Neg (Succ vuv300)) (Neg (Succ vuv300) >= fromInt (Pos Zero))",fontsize=16,color="black",shape="box"];244 -> 258[label="",style="solid", color="black", weight=3];
245[label="vuv400",fontsize=16,color="green",shape="box"];246[label="abs (Neg Zero)",fontsize=16,color="black",shape="triangle"];246 -> 259[label="",style="solid", color="black", weight=3];
247 -> 252[label="",style="dashed", color="red", weight=0];
247[label="gcd0Gcd'1 (primEqInt (`negate` Neg (Succ vuv400)) (fromInt (Pos Zero))) (abs (Neg Zero)) (`negate` Neg (Succ vuv400))",fontsize=16,color="magenta"];247 -> 256[label="",style="dashed", color="magenta", weight=3];
248[label="gcd0Gcd'2 (Pos (Succ vuv400)) (vuv6 `rem` Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];248 -> 260[label="",style="solid", color="black", weight=3];
249[label="absReal1 (Pos (Succ vuv300)) (compare (Pos (Succ vuv300)) (fromInt (Pos Zero)) /= LT)",fontsize=16,color="black",shape="box"];249 -> 261[label="",style="solid", color="black", weight=3];
240[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv400)) (Pos Zero)) vuv5 (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];240 -> 250[label="",style="solid", color="black", weight=3];
251[label="absReal (Pos Zero)",fontsize=16,color="black",shape="box"];251 -> 262[label="",style="solid", color="black", weight=3];
255 -> 242[label="",style="dashed", color="red", weight=0];
255[label="abs (Pos Zero)",fontsize=16,color="magenta"];258[label="absReal1 (Neg (Succ vuv300)) (compare (Neg (Succ vuv300)) (fromInt (Pos Zero)) /= LT)",fontsize=16,color="black",shape="box"];258 -> 265[label="",style="solid", color="black", weight=3];
259[label="absReal (Neg Zero)",fontsize=16,color="black",shape="box"];259 -> 266[label="",style="solid", color="black", weight=3];
256 -> 246[label="",style="dashed", color="red", weight=0];
256[label="abs (Neg Zero)",fontsize=16,color="magenta"];260[label="gcd0Gcd'1 (vuv6 `rem` Pos (Succ vuv400) == fromInt (Pos Zero)) (Pos (Succ vuv400)) (vuv6 `rem` Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];260 -> 267[label="",style="solid", color="black", weight=3];
261[label="absReal1 (Pos (Succ vuv300)) (not (compare (Pos (Succ vuv300)) (fromInt (Pos Zero)) == LT))",fontsize=16,color="black",shape="box"];261 -> 268[label="",style="solid", color="black", weight=3];
250[label="gcd0Gcd'1 False vuv5 (Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];250 -> 263[label="",style="solid", color="black", weight=3];
262[label="absReal2 (Pos Zero)",fontsize=16,color="black",shape="box"];262 -> 269[label="",style="solid", color="black", weight=3];
265[label="absReal1 (Neg (Succ vuv300)) (not (compare (Neg (Succ vuv300)) (fromInt (Pos Zero)) == LT))",fontsize=16,color="black",shape="box"];265 -> 273[label="",style="solid", color="black", weight=3];
266[label="absReal2 (Neg Zero)",fontsize=16,color="black",shape="box"];266 -> 274[label="",style="solid", color="black", weight=3];
267[label="gcd0Gcd'1 (primEqInt (vuv6 `rem` Pos (Succ vuv400)) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (vuv6 `rem` Pos (Succ vuv400))",fontsize=16,color="black",shape="box"];267 -> 275[label="",style="solid", color="black", weight=3];
268[label="absReal1 (Pos (Succ vuv300)) (not (primCmpInt (Pos (Succ vuv300)) (fromInt (Pos Zero)) == LT))",fontsize=16,color="black",shape="box"];268 -> 276[label="",style="solid", color="black", weight=3];
263 -> 228[label="",style="dashed", color="red", weight=0];
263[label="gcd0Gcd'0 vuv5 (Pos (Succ vuv400))",fontsize=16,color="magenta"];263 -> 270[label="",style="dashed", color="magenta", weight=3];
263 -> 271[label="",style="dashed", color="magenta", weight=3];
269[label="absReal1 (Pos Zero) (Pos Zero >= fromInt (Pos Zero))",fontsize=16,color="black",shape="box"];269 -> 277[label="",style="solid", color="black", weight=3];
273[label="absReal1 (Neg (Succ vuv300)) (not (primCmpInt (Neg (Succ vuv300)) (fromInt (Pos Zero)) == LT))",fontsize=16,color="black",shape="box"];273 -> 278[label="",style="solid", color="black", weight=3];
274[label="absReal1 (Neg Zero) (Neg Zero >= fromInt (Pos Zero))",fontsize=16,color="black",shape="box"];274 -> 279[label="",style="solid", color="black", weight=3];
275[label="gcd0Gcd'1 (primEqInt (primRemInt vuv6 (Pos (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (primRemInt vuv6 (Pos (Succ vuv400)))",fontsize=16,color="burlywood",shape="box"];1560[label="vuv6/Pos vuv60",fontsize=10,color="white",style="solid",shape="box"];275 -> 1560[label="",style="solid", color="burlywood", weight=9];
1560 -> 280[label="",style="solid", color="burlywood", weight=3];
1561[label="vuv6/Neg vuv60",fontsize=10,color="white",style="solid",shape="box"];275 -> 1561[label="",style="solid", color="burlywood", weight=9];
1561 -> 281[label="",style="solid", color="burlywood", weight=3];
276[label="absReal1 (Pos (Succ vuv300)) (not (primCmpInt (Pos (Succ vuv300)) (Pos Zero) == LT))",fontsize=16,color="black",shape="box"];276 -> 282[label="",style="solid", color="black", weight=3];
270[label="vuv5",fontsize=16,color="green",shape="box"];271[label="vuv400",fontsize=16,color="green",shape="box"];277[label="absReal1 (Pos Zero) (compare (Pos Zero) (fromInt (Pos Zero)) /= LT)",fontsize=16,color="black",shape="box"];277 -> 283[label="",style="solid", color="black", weight=3];
278[label="absReal1 (Neg (Succ vuv300)) (not (primCmpInt (Neg (Succ vuv300)) (Pos Zero) == LT))",fontsize=16,color="black",shape="box"];278 -> 284[label="",style="solid", color="black", weight=3];
279[label="absReal1 (Neg Zero) (compare (Neg Zero) (fromInt (Pos Zero)) /= LT)",fontsize=16,color="black",shape="box"];279 -> 285[label="",style="solid", color="black", weight=3];
280[label="gcd0Gcd'1 (primEqInt (primRemInt (Pos vuv60) (Pos (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (primRemInt (Pos vuv60) (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];280 -> 286[label="",style="solid", color="black", weight=3];
281[label="gcd0Gcd'1 (primEqInt (primRemInt (Neg vuv60) (Pos (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (primRemInt (Neg vuv60) (Pos (Succ vuv400)))",fontsize=16,color="black",shape="box"];281 -> 287[label="",style="solid", color="black", weight=3];
282[label="absReal1 (Pos (Succ vuv300)) (not (primCmpNat (Succ vuv300) Zero == LT))",fontsize=16,color="black",shape="box"];282 -> 288[label="",style="solid", color="black", weight=3];
283[label="absReal1 (Pos Zero) (not (compare (Pos Zero) (fromInt (Pos Zero)) == LT))",fontsize=16,color="black",shape="box"];283 -> 289[label="",style="solid", color="black", weight=3];
284[label="absReal1 (Neg (Succ vuv300)) (not (LT == LT))",fontsize=16,color="black",shape="box"];284 -> 290[label="",style="solid", color="black", weight=3];
285[label="absReal1 (Neg Zero) (not (compare (Neg Zero) (fromInt (Pos Zero)) == LT))",fontsize=16,color="black",shape="box"];285 -> 291[label="",style="solid", color="black", weight=3];
286[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS vuv60 (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Pos (primModNatS vuv60 (Succ vuv400)))",fontsize=16,color="burlywood",shape="triangle"];1562[label="vuv60/Succ vuv600",fontsize=10,color="white",style="solid",shape="box"];286 -> 1562[label="",style="solid", color="burlywood", weight=9];
1562 -> 292[label="",style="solid", color="burlywood", weight=3];
1563[label="vuv60/Zero",fontsize=10,color="white",style="solid",shape="box"];286 -> 1563[label="",style="solid", color="burlywood", weight=9];
1563 -> 293[label="",style="solid", color="burlywood", weight=3];
287[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS vuv60 (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Neg (primModNatS vuv60 (Succ vuv400)))",fontsize=16,color="burlywood",shape="triangle"];1564[label="vuv60/Succ vuv600",fontsize=10,color="white",style="solid",shape="box"];287 -> 1564[label="",style="solid", color="burlywood", weight=9];
1564 -> 294[label="",style="solid", color="burlywood", weight=3];
1565[label="vuv60/Zero",fontsize=10,color="white",style="solid",shape="box"];287 -> 1565[label="",style="solid", color="burlywood", weight=9];
1565 -> 295[label="",style="solid", color="burlywood", weight=3];
288[label="absReal1 (Pos (Succ vuv300)) (not (GT == LT))",fontsize=16,color="black",shape="box"];288 -> 296[label="",style="solid", color="black", weight=3];
289[label="absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (fromInt (Pos Zero)) == LT))",fontsize=16,color="black",shape="box"];289 -> 297[label="",style="solid", color="black", weight=3];
290[label="absReal1 (Neg (Succ vuv300)) (not True)",fontsize=16,color="black",shape="box"];290 -> 298[label="",style="solid", color="black", weight=3];
291[label="absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (fromInt (Pos Zero)) == LT))",fontsize=16,color="black",shape="box"];291 -> 299[label="",style="solid", color="black", weight=3];
292[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS (Succ vuv600) (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Pos (primModNatS (Succ vuv600) (Succ vuv400)))",fontsize=16,color="black",shape="box"];292 -> 300[label="",style="solid", color="black", weight=3];
293[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS Zero (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Pos (primModNatS Zero (Succ vuv400)))",fontsize=16,color="black",shape="box"];293 -> 301[label="",style="solid", color="black", weight=3];
294[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS (Succ vuv600) (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Neg (primModNatS (Succ vuv600) (Succ vuv400)))",fontsize=16,color="black",shape="box"];294 -> 302[label="",style="solid", color="black", weight=3];
295[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS Zero (Succ vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Neg (primModNatS Zero (Succ vuv400)))",fontsize=16,color="black",shape="box"];295 -> 303[label="",style="solid", color="black", weight=3];
296[label="absReal1 (Pos (Succ vuv300)) (not False)",fontsize=16,color="black",shape="box"];296 -> 304[label="",style="solid", color="black", weight=3];
297[label="absReal1 (Pos Zero) (not (primCmpInt (Pos Zero) (Pos Zero) == LT))",fontsize=16,color="black",shape="box"];297 -> 305[label="",style="solid", color="black", weight=3];
298[label="absReal1 (Neg (Succ vuv300)) False",fontsize=16,color="black",shape="box"];298 -> 306[label="",style="solid", color="black", weight=3];
299[label="absReal1 (Neg Zero) (not (primCmpInt (Neg Zero) (Pos Zero) == LT))",fontsize=16,color="black",shape="box"];299 -> 307[label="",style="solid", color="black", weight=3];
300[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 vuv600 vuv400 (primGEqNatS vuv600 vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Pos (primModNatS0 vuv600 vuv400 (primGEqNatS vuv600 vuv400)))",fontsize=16,color="burlywood",shape="box"];1566[label="vuv600/Succ vuv6000",fontsize=10,color="white",style="solid",shape="box"];300 -> 1566[label="",style="solid", color="burlywood", weight=9];
1566 -> 308[label="",style="solid", color="burlywood", weight=3];
1567[label="vuv600/Zero",fontsize=10,color="white",style="solid",shape="box"];300 -> 1567[label="",style="solid", color="burlywood", weight=9];
1567 -> 309[label="",style="solid", color="burlywood", weight=3];
301[label="gcd0Gcd'1 (primEqInt (Pos Zero) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Pos Zero)",fontsize=16,color="black",shape="box"];301 -> 310[label="",style="solid", color="black", weight=3];
302[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 vuv600 vuv400 (primGEqNatS vuv600 vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Neg (primModNatS0 vuv600 vuv400 (primGEqNatS vuv600 vuv400)))",fontsize=16,color="burlywood",shape="box"];1568[label="vuv600/Succ vuv6000",fontsize=10,color="white",style="solid",shape="box"];302 -> 1568[label="",style="solid", color="burlywood", weight=9];
1568 -> 311[label="",style="solid", color="burlywood", weight=3];
1569[label="vuv600/Zero",fontsize=10,color="white",style="solid",shape="box"];302 -> 1569[label="",style="solid", color="burlywood", weight=9];
1569 -> 312[label="",style="solid", color="burlywood", weight=3];
303[label="gcd0Gcd'1 (primEqInt (Neg Zero) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Neg Zero)",fontsize=16,color="black",shape="box"];303 -> 313[label="",style="solid", color="black", weight=3];
304[label="absReal1 (Pos (Succ vuv300)) True",fontsize=16,color="black",shape="box"];304 -> 314[label="",style="solid", color="black", weight=3];
305[label="absReal1 (Pos Zero) (not (EQ == LT))",fontsize=16,color="black",shape="box"];305 -> 315[label="",style="solid", color="black", weight=3];
306[label="absReal0 (Neg (Succ vuv300)) otherwise",fontsize=16,color="black",shape="box"];306 -> 316[label="",style="solid", color="black", weight=3];
307[label="absReal1 (Neg Zero) (not (EQ == LT))",fontsize=16,color="black",shape="box"];307 -> 317[label="",style="solid", color="black", weight=3];
308[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6000) vuv400 (primGEqNatS (Succ vuv6000) vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Pos (primModNatS0 (Succ vuv6000) vuv400 (primGEqNatS (Succ vuv6000) vuv400)))",fontsize=16,color="burlywood",shape="box"];1570[label="vuv400/Succ vuv4000",fontsize=10,color="white",style="solid",shape="box"];308 -> 1570[label="",style="solid", color="burlywood", weight=9];
1570 -> 318[label="",style="solid", color="burlywood", weight=3];
1571[label="vuv400/Zero",fontsize=10,color="white",style="solid",shape="box"];308 -> 1571[label="",style="solid", color="burlywood", weight=9];
1571 -> 319[label="",style="solid", color="burlywood", weight=3];
309[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero vuv400 (primGEqNatS Zero vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Pos (primModNatS0 Zero vuv400 (primGEqNatS Zero vuv400)))",fontsize=16,color="burlywood",shape="box"];1572[label="vuv400/Succ vuv4000",fontsize=10,color="white",style="solid",shape="box"];309 -> 1572[label="",style="solid", color="burlywood", weight=9];
1572 -> 320[label="",style="solid", color="burlywood", weight=3];
1573[label="vuv400/Zero",fontsize=10,color="white",style="solid",shape="box"];309 -> 1573[label="",style="solid", color="burlywood", weight=9];
1573 -> 321[label="",style="solid", color="burlywood", weight=3];
310[label="gcd0Gcd'1 (primEqInt (Pos Zero) (Pos Zero)) (Pos (Succ vuv400)) (Pos Zero)",fontsize=16,color="black",shape="box"];310 -> 322[label="",style="solid", color="black", weight=3];
311[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv6000) vuv400 (primGEqNatS (Succ vuv6000) vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Neg (primModNatS0 (Succ vuv6000) vuv400 (primGEqNatS (Succ vuv6000) vuv400)))",fontsize=16,color="burlywood",shape="box"];1574[label="vuv400/Succ vuv4000",fontsize=10,color="white",style="solid",shape="box"];311 -> 1574[label="",style="solid", color="burlywood", weight=9];
1574 -> 323[label="",style="solid", color="burlywood", weight=3];
1575[label="vuv400/Zero",fontsize=10,color="white",style="solid",shape="box"];311 -> 1575[label="",style="solid", color="burlywood", weight=9];
1575 -> 324[label="",style="solid", color="burlywood", weight=3];
312[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 Zero vuv400 (primGEqNatS Zero vuv400))) (fromInt (Pos Zero))) (Pos (Succ vuv400)) (Neg (primModNatS0 Zero vuv400 (primGEqNatS Zero vuv400)))",fontsize=16,color="burlywood",shape="box"];1576[label="vuv400/Succ vuv4000",fontsize=10,color="white",style="solid",shape="box"];312 -> 1576[label="",style="solid", color="burlywood", weight=9];
1576 -> 325[label="",style="solid", color="burlywood", weight=3];
1577[label="vuv400/Zero",fontsize=10,color="white",style="solid",shape="box"];312 -> 1577[label="",style="solid", color="burlywood", weight=9];
1577 -> 326[label="",style="solid", color="burlywood", weight=3];
313[label="gcd0Gcd'1 (primEqInt (Neg Zero) (Pos Zero)) (Pos (Succ vuv400)) (Neg Zero)",fontsize=16,color="black",shape="box"];313 -> 327[label="",style="solid", color="black", weight=3];
314[label="Pos (Succ vuv300)",fontsize=16,color="green",shape="box"];315[label="absReal1 (Pos Zero) (not False)",fontsize=16,color="black",shape="box"];315 -> 328[label="",style="solid", color="black", weight=3];
316[label="absReal0 (Neg (Succ vuv300)) True",fontsize=16,color="black",shape="box"];316 -> 329[label="",style="solid", color="black", weight=3];
317[label="absReal1 (Neg Zero) (not False)",fontsize=16,color="black",shape="box"];317 -> 330[label="",style="solid", color="black", weight=3];
318[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6000) (Succ vuv4000) (primGEqNatS (Succ vuv6000) (Succ vuv4000)))) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Pos (primModNatS0 (Succ vuv6000) (Succ vuv4000) (primGEqNatS (Succ vuv6000) (Succ vuv4000))))",fontsize=16,color="black",shape="box"];318 -> 331[label="",style="solid", color="black", weight=3];
319[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6000) Zero (primGEqNatS (Succ vuv6000) Zero))) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Pos (primModNatS0 (Succ vuv6000) Zero (primGEqNatS (Succ vuv6000) Zero)))",fontsize=16,color="black",shape="box"];319 -> 332[label="",style="solid", color="black", weight=3];
320[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero (Succ vuv4000) (primGEqNatS Zero (Succ vuv4000)))) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Pos (primModNatS0 Zero (Succ vuv4000) (primGEqNatS Zero (Succ vuv4000))))",fontsize=16,color="black",shape="box"];320 -> 333[label="",style="solid", color="black", weight=3];
321[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero Zero (primGEqNatS Zero Zero))) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Pos (primModNatS0 Zero Zero (primGEqNatS Zero Zero)))",fontsize=16,color="black",shape="box"];321 -> 334[label="",style="solid", color="black", weight=3];
322[label="gcd0Gcd'1 True (Pos (Succ vuv400)) (Pos Zero)",fontsize=16,color="black",shape="box"];322 -> 335[label="",style="solid", color="black", weight=3];
323[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv6000) (Succ vuv4000) (primGEqNatS (Succ vuv6000) (Succ vuv4000)))) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Neg (primModNatS0 (Succ vuv6000) (Succ vuv4000) (primGEqNatS (Succ vuv6000) (Succ vuv4000))))",fontsize=16,color="black",shape="box"];323 -> 336[label="",style="solid", color="black", weight=3];
324[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv6000) Zero (primGEqNatS (Succ vuv6000) Zero))) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Neg (primModNatS0 (Succ vuv6000) Zero (primGEqNatS (Succ vuv6000) Zero)))",fontsize=16,color="black",shape="box"];324 -> 337[label="",style="solid", color="black", weight=3];
325[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 Zero (Succ vuv4000) (primGEqNatS Zero (Succ vuv4000)))) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Neg (primModNatS0 Zero (Succ vuv4000) (primGEqNatS Zero (Succ vuv4000))))",fontsize=16,color="black",shape="box"];325 -> 338[label="",style="solid", color="black", weight=3];
326[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 Zero Zero (primGEqNatS Zero Zero))) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Neg (primModNatS0 Zero Zero (primGEqNatS Zero Zero)))",fontsize=16,color="black",shape="box"];326 -> 339[label="",style="solid", color="black", weight=3];
327[label="gcd0Gcd'1 True (Pos (Succ vuv400)) (Neg Zero)",fontsize=16,color="black",shape="box"];327 -> 340[label="",style="solid", color="black", weight=3];
328[label="absReal1 (Pos Zero) True",fontsize=16,color="black",shape="box"];328 -> 341[label="",style="solid", color="black", weight=3];
329[label="`negate` Neg (Succ vuv300)",fontsize=16,color="black",shape="box"];329 -> 342[label="",style="solid", color="black", weight=3];
330[label="absReal1 (Neg Zero) True",fontsize=16,color="black",shape="box"];330 -> 343[label="",style="solid", color="black", weight=3];
331 -> 821[label="",style="dashed", color="red", weight=0];
331[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6000) (Succ vuv4000) (primGEqNatS vuv6000 vuv4000))) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Pos (primModNatS0 (Succ vuv6000) (Succ vuv4000) (primGEqNatS vuv6000 vuv4000)))",fontsize=16,color="magenta"];331 -> 822[label="",style="dashed", color="magenta", weight=3];
331 -> 823[label="",style="dashed", color="magenta", weight=3];
331 -> 824[label="",style="dashed", color="magenta", weight=3];
331 -> 825[label="",style="dashed", color="magenta", weight=3];
332 -> 613[label="",style="dashed", color="red", weight=0];
332[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6000) Zero True)) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Pos (primModNatS0 (Succ vuv6000) Zero True))",fontsize=16,color="magenta"];332 -> 614[label="",style="dashed", color="magenta", weight=3];
332 -> 615[label="",style="dashed", color="magenta", weight=3];
333[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero (Succ vuv4000) False)) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Pos (primModNatS0 Zero (Succ vuv4000) False))",fontsize=16,color="black",shape="box"];333 -> 347[label="",style="solid", color="black", weight=3];
334[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero Zero True)) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Pos (primModNatS0 Zero Zero True))",fontsize=16,color="black",shape="box"];334 -> 348[label="",style="solid", color="black", weight=3];
335[label="Pos (Succ vuv400)",fontsize=16,color="green",shape="box"];336 -> 865[label="",style="dashed", color="red", weight=0];
336[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv6000) (Succ vuv4000) (primGEqNatS vuv6000 vuv4000))) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Neg (primModNatS0 (Succ vuv6000) (Succ vuv4000) (primGEqNatS vuv6000 vuv4000)))",fontsize=16,color="magenta"];336 -> 866[label="",style="dashed", color="magenta", weight=3];
336 -> 867[label="",style="dashed", color="magenta", weight=3];
336 -> 868[label="",style="dashed", color="magenta", weight=3];
336 -> 869[label="",style="dashed", color="magenta", weight=3];
337 -> 644[label="",style="dashed", color="red", weight=0];
337[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv6000) Zero True)) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Neg (primModNatS0 (Succ vuv6000) Zero True))",fontsize=16,color="magenta"];337 -> 645[label="",style="dashed", color="magenta", weight=3];
337 -> 646[label="",style="dashed", color="magenta", weight=3];
338[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 Zero (Succ vuv4000) False)) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Neg (primModNatS0 Zero (Succ vuv4000) False))",fontsize=16,color="black",shape="box"];338 -> 352[label="",style="solid", color="black", weight=3];
339[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 Zero Zero True)) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Neg (primModNatS0 Zero Zero True))",fontsize=16,color="black",shape="box"];339 -> 353[label="",style="solid", color="black", weight=3];
340[label="Pos (Succ vuv400)",fontsize=16,color="green",shape="box"];341[label="Pos Zero",fontsize=16,color="green",shape="box"];342[label="primNegInt (Neg (Succ vuv300))",fontsize=16,color="black",shape="box"];342 -> 354[label="",style="solid", color="black", weight=3];
343[label="Neg Zero",fontsize=16,color="green",shape="box"];822[label="vuv6000",fontsize=16,color="green",shape="box"];823[label="Succ vuv4000",fontsize=16,color="green",shape="box"];824[label="vuv4000",fontsize=16,color="green",shape="box"];825[label="vuv6000",fontsize=16,color="green",shape="box"];821[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS vuv37 vuv38))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS vuv37 vuv38)))",fontsize=16,color="burlywood",shape="triangle"];1582[label="vuv37/Succ vuv370",fontsize=10,color="white",style="solid",shape="box"];821 -> 1582[label="",style="solid", color="burlywood", weight=9];
1582 -> 862[label="",style="solid", color="burlywood", weight=3];
1583[label="vuv37/Zero",fontsize=10,color="white",style="solid",shape="box"];821 -> 1583[label="",style="solid", color="burlywood", weight=9];
1583 -> 863[label="",style="solid", color="burlywood", weight=3];
614[label="vuv6000",fontsize=16,color="green",shape="box"];615[label="Zero",fontsize=16,color="green",shape="box"];613[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv23) vuv24 True)) (fromInt (Pos Zero))) (Pos (Succ vuv24)) (Pos (primModNatS0 (Succ vuv23) vuv24 True))",fontsize=16,color="black",shape="triangle"];613 -> 636[label="",style="solid", color="black", weight=3];
347 -> 232[label="",style="dashed", color="red", weight=0];
347[label="gcd0Gcd'1 (primEqInt (Pos (Succ Zero)) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Pos (Succ Zero))",fontsize=16,color="magenta"];347 -> 361[label="",style="dashed", color="magenta", weight=3];
347 -> 362[label="",style="dashed", color="magenta", weight=3];
348 -> 286[label="",style="dashed", color="red", weight=0];
348[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS (primMinusNatS Zero Zero) (Succ Zero))) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Pos (primModNatS (primMinusNatS Zero Zero) (Succ Zero)))",fontsize=16,color="magenta"];348 -> 363[label="",style="dashed", color="magenta", weight=3];
348 -> 364[label="",style="dashed", color="magenta", weight=3];
866[label="vuv6000",fontsize=16,color="green",shape="box"];867[label="vuv4000",fontsize=16,color="green",shape="box"];868[label="Succ vuv4000",fontsize=16,color="green",shape="box"];869[label="vuv6000",fontsize=16,color="green",shape="box"];865[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS vuv42 vuv43))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS vuv42 vuv43)))",fontsize=16,color="burlywood",shape="triangle"];1586[label="vuv42/Succ vuv420",fontsize=10,color="white",style="solid",shape="box"];865 -> 1586[label="",style="solid", color="burlywood", weight=9];
1586 -> 906[label="",style="solid", color="burlywood", weight=3];
1587[label="vuv42/Zero",fontsize=10,color="white",style="solid",shape="box"];865 -> 1587[label="",style="solid", color="burlywood", weight=9];
1587 -> 907[label="",style="solid", color="burlywood", weight=3];
645[label="vuv6000",fontsize=16,color="green",shape="box"];646[label="Zero",fontsize=16,color="green",shape="box"];644[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv26) vuv27 True)) (fromInt (Pos Zero))) (Pos (Succ vuv27)) (Neg (primModNatS0 (Succ vuv26) vuv27 True))",fontsize=16,color="black",shape="triangle"];644 -> 667[label="",style="solid", color="black", weight=3];
352 -> 687[label="",style="dashed", color="red", weight=0];
352[label="gcd0Gcd'1 (primEqInt (Neg (Succ Zero)) (fromInt (Pos Zero))) (Pos (Succ (Succ vuv4000))) (Neg (Succ Zero))",fontsize=16,color="magenta"];352 -> 688[label="",style="dashed", color="magenta", weight=3];
352 -> 689[label="",style="dashed", color="magenta", weight=3];
353 -> 287[label="",style="dashed", color="red", weight=0];
353[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS (primMinusNatS Zero Zero) (Succ Zero))) (fromInt (Pos Zero))) (Pos (Succ Zero)) (Neg (primModNatS (primMinusNatS Zero Zero) (Succ Zero)))",fontsize=16,color="magenta"];353 -> 372[label="",style="dashed", color="magenta", weight=3];
353 -> 373[label="",style="dashed", color="magenta", weight=3];
354[label="Pos (Succ vuv300)",fontsize=16,color="green",shape="box"];862[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS (Succ vuv370) vuv38))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS (Succ vuv370) vuv38)))",fontsize=16,color="burlywood",shape="box"];1590[label="vuv38/Succ vuv380",fontsize=10,color="white",style="solid",shape="box"];862 -> 1590[label="",style="solid", color="burlywood", weight=9];
1590 -> 908[label="",style="solid", color="burlywood", weight=3];
1591[label="vuv38/Zero",fontsize=10,color="white",style="solid",shape="box"];862 -> 1591[label="",style="solid", color="burlywood", weight=9];
1591 -> 909[label="",style="solid", color="burlywood", weight=3];
863[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS Zero vuv38))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS Zero vuv38)))",fontsize=16,color="burlywood",shape="box"];1592[label="vuv38/Succ vuv380",fontsize=10,color="white",style="solid",shape="box"];863 -> 1592[label="",style="solid", color="burlywood", weight=9];
1592 -> 910[label="",style="solid", color="burlywood", weight=3];
1593[label="vuv38/Zero",fontsize=10,color="white",style="solid",shape="box"];863 -> 1593[label="",style="solid", color="burlywood", weight=9];
1593 -> 911[label="",style="solid", color="burlywood", weight=3];
636 -> 286[label="",style="dashed", color="red", weight=0];
636[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS (primMinusNatS (Succ vuv23) vuv24) (Succ vuv24))) (fromInt (Pos Zero))) (Pos (Succ vuv24)) (Pos (primModNatS (primMinusNatS (Succ vuv23) vuv24) (Succ vuv24)))",fontsize=16,color="magenta"];636 -> 668[label="",style="dashed", color="magenta", weight=3];
636 -> 669[label="",style="dashed", color="magenta", weight=3];
361[label="Zero",fontsize=16,color="green",shape="box"];362[label="Pos (Succ (Succ vuv4000))",fontsize=16,color="green",shape="box"];363[label="primMinusNatS Zero Zero",fontsize=16,color="black",shape="triangle"];363 -> 379[label="",style="solid", color="black", weight=3];
364[label="Zero",fontsize=16,color="green",shape="box"];906[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS (Succ vuv420) vuv43))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS (Succ vuv420) vuv43)))",fontsize=16,color="burlywood",shape="box"];1595[label="vuv43/Succ vuv430",fontsize=10,color="white",style="solid",shape="box"];906 -> 1595[label="",style="solid", color="burlywood", weight=9];
1595 -> 913[label="",style="solid", color="burlywood", weight=3];
1596[label="vuv43/Zero",fontsize=10,color="white",style="solid",shape="box"];906 -> 1596[label="",style="solid", color="burlywood", weight=9];
1596 -> 914[label="",style="solid", color="burlywood", weight=3];
907[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS Zero vuv43))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS Zero vuv43)))",fontsize=16,color="burlywood",shape="box"];1597[label="vuv43/Succ vuv430",fontsize=10,color="white",style="solid",shape="box"];907 -> 1597[label="",style="solid", color="burlywood", weight=9];
1597 -> 915[label="",style="solid", color="burlywood", weight=3];
1598[label="vuv43/Zero",fontsize=10,color="white",style="solid",shape="box"];907 -> 1598[label="",style="solid", color="burlywood", weight=9];
1598 -> 916[label="",style="solid", color="burlywood", weight=3];
667 -> 287[label="",style="dashed", color="red", weight=0];
667[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS (primMinusNatS (Succ vuv26) vuv27) (Succ vuv27))) (fromInt (Pos Zero))) (Pos (Succ vuv27)) (Neg (primModNatS (primMinusNatS (Succ vuv26) vuv27) (Succ vuv27)))",fontsize=16,color="magenta"];667 -> 700[label="",style="dashed", color="magenta", weight=3];
667 -> 701[label="",style="dashed", color="magenta", weight=3];
688[label="Zero",fontsize=16,color="green",shape="box"];689[label="Succ vuv4000",fontsize=16,color="green",shape="box"];687[label="gcd0Gcd'1 (primEqInt (Neg (Succ vuv29)) (fromInt (Pos Zero))) (Pos (Succ vuv30)) (Neg (Succ vuv29))",fontsize=16,color="black",shape="triangle"];687 -> 702[label="",style="solid", color="black", weight=3];
372 -> 363[label="",style="dashed", color="red", weight=0];
372[label="primMinusNatS Zero Zero",fontsize=16,color="magenta"];373[label="Zero",fontsize=16,color="green",shape="box"];908[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS (Succ vuv370) (Succ vuv380)))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS (Succ vuv370) (Succ vuv380))))",fontsize=16,color="black",shape="box"];908 -> 917[label="",style="solid", color="black", weight=3];
909[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS (Succ vuv370) Zero))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS (Succ vuv370) Zero)))",fontsize=16,color="black",shape="box"];909 -> 918[label="",style="solid", color="black", weight=3];
910[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS Zero (Succ vuv380)))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS Zero (Succ vuv380))))",fontsize=16,color="black",shape="box"];910 -> 919[label="",style="solid", color="black", weight=3];
911[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS Zero Zero))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS Zero Zero)))",fontsize=16,color="black",shape="box"];911 -> 920[label="",style="solid", color="black", weight=3];
668[label="primMinusNatS (Succ vuv23) vuv24",fontsize=16,color="burlywood",shape="triangle"];1601[label="vuv24/Succ vuv240",fontsize=10,color="white",style="solid",shape="box"];668 -> 1601[label="",style="solid", color="burlywood", weight=9];
1601 -> 703[label="",style="solid", color="burlywood", weight=3];
1602[label="vuv24/Zero",fontsize=10,color="white",style="solid",shape="box"];668 -> 1602[label="",style="solid", color="burlywood", weight=9];
1602 -> 704[label="",style="solid", color="burlywood", weight=3];
669[label="vuv24",fontsize=16,color="green",shape="box"];379[label="Zero",fontsize=16,color="green",shape="box"];913[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS (Succ vuv420) (Succ vuv430)))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS (Succ vuv420) (Succ vuv430))))",fontsize=16,color="black",shape="box"];913 -> 923[label="",style="solid", color="black", weight=3];
914[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS (Succ vuv420) Zero))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS (Succ vuv420) Zero)))",fontsize=16,color="black",shape="box"];914 -> 924[label="",style="solid", color="black", weight=3];
915[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS Zero (Succ vuv430)))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS Zero (Succ vuv430))))",fontsize=16,color="black",shape="box"];915 -> 925[label="",style="solid", color="black", weight=3];
916[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS Zero Zero))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS Zero Zero)))",fontsize=16,color="black",shape="box"];916 -> 926[label="",style="solid", color="black", weight=3];
700 -> 668[label="",style="dashed", color="red", weight=0];
700[label="primMinusNatS (Succ vuv26) vuv27",fontsize=16,color="magenta"];700 -> 713[label="",style="dashed", color="magenta", weight=3];
700 -> 714[label="",style="dashed", color="magenta", weight=3];
701[label="vuv27",fontsize=16,color="green",shape="box"];702[label="gcd0Gcd'1 (primEqInt (Neg (Succ vuv29)) (Pos Zero)) (Pos (Succ vuv30)) (Neg (Succ vuv29))",fontsize=16,color="black",shape="box"];702 -> 715[label="",style="solid", color="black", weight=3];
917 -> 821[label="",style="dashed", color="red", weight=0];
917[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS vuv370 vuv380))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 (primGEqNatS vuv370 vuv380)))",fontsize=16,color="magenta"];917 -> 927[label="",style="dashed", color="magenta", weight=3];
917 -> 928[label="",style="dashed", color="magenta", weight=3];
918 -> 613[label="",style="dashed", color="red", weight=0];
918[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 True)) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 True))",fontsize=16,color="magenta"];918 -> 929[label="",style="dashed", color="magenta", weight=3];
918 -> 930[label="",style="dashed", color="magenta", weight=3];
919[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 False)) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 False))",fontsize=16,color="black",shape="box"];919 -> 931[label="",style="solid", color="black", weight=3];
920 -> 613[label="",style="dashed", color="red", weight=0];
920[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv35) vuv36 True)) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (primModNatS0 (Succ vuv35) vuv36 True))",fontsize=16,color="magenta"];920 -> 932[label="",style="dashed", color="magenta", weight=3];
920 -> 933[label="",style="dashed", color="magenta", weight=3];
703[label="primMinusNatS (Succ vuv23) (Succ vuv240)",fontsize=16,color="black",shape="box"];703 -> 716[label="",style="solid", color="black", weight=3];
704[label="primMinusNatS (Succ vuv23) Zero",fontsize=16,color="black",shape="box"];704 -> 717[label="",style="solid", color="black", weight=3];
923 -> 865[label="",style="dashed", color="red", weight=0];
923[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS vuv420 vuv430))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 (primGEqNatS vuv420 vuv430)))",fontsize=16,color="magenta"];923 -> 938[label="",style="dashed", color="magenta", weight=3];
923 -> 939[label="",style="dashed", color="magenta", weight=3];
924 -> 644[label="",style="dashed", color="red", weight=0];
924[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 True)) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 True))",fontsize=16,color="magenta"];924 -> 940[label="",style="dashed", color="magenta", weight=3];
924 -> 941[label="",style="dashed", color="magenta", weight=3];
925[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 False)) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 False))",fontsize=16,color="black",shape="box"];925 -> 942[label="",style="solid", color="black", weight=3];
926 -> 644[label="",style="dashed", color="red", weight=0];
926[label="gcd0Gcd'1 (primEqInt (Neg (primModNatS0 (Succ vuv40) vuv41 True)) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (primModNatS0 (Succ vuv40) vuv41 True))",fontsize=16,color="magenta"];926 -> 943[label="",style="dashed", color="magenta", weight=3];
926 -> 944[label="",style="dashed", color="magenta", weight=3];
713[label="vuv26",fontsize=16,color="green",shape="box"];714[label="vuv27",fontsize=16,color="green",shape="box"];715[label="gcd0Gcd'1 False (Pos (Succ vuv30)) (Neg (Succ vuv29))",fontsize=16,color="black",shape="box"];715 -> 732[label="",style="solid", color="black", weight=3];
927[label="vuv370",fontsize=16,color="green",shape="box"];928[label="vuv380",fontsize=16,color="green",shape="box"];929[label="vuv35",fontsize=16,color="green",shape="box"];930[label="vuv36",fontsize=16,color="green",shape="box"];931 -> 232[label="",style="dashed", color="red", weight=0];
931[label="gcd0Gcd'1 (primEqInt (Pos (Succ (Succ vuv35))) (fromInt (Pos Zero))) (Pos (Succ vuv36)) (Pos (Succ (Succ vuv35)))",fontsize=16,color="magenta"];931 -> 945[label="",style="dashed", color="magenta", weight=3];
931 -> 946[label="",style="dashed", color="magenta", weight=3];
932[label="vuv35",fontsize=16,color="green",shape="box"];933[label="vuv36",fontsize=16,color="green",shape="box"];716[label="primMinusNatS vuv23 vuv240",fontsize=16,color="burlywood",shape="triangle"];1611[label="vuv23/Succ vuv230",fontsize=10,color="white",style="solid",shape="box"];716 -> 1611[label="",style="solid", color="burlywood", weight=9];
1611 -> 733[label="",style="solid", color="burlywood", weight=3];
1612[label="vuv23/Zero",fontsize=10,color="white",style="solid",shape="box"];716 -> 1612[label="",style="solid", color="burlywood", weight=9];
1612 -> 734[label="",style="solid", color="burlywood", weight=3];
717[label="Succ vuv23",fontsize=16,color="green",shape="box"];938[label="vuv430",fontsize=16,color="green",shape="box"];939[label="vuv420",fontsize=16,color="green",shape="box"];940[label="vuv40",fontsize=16,color="green",shape="box"];941[label="vuv41",fontsize=16,color="green",shape="box"];942 -> 687[label="",style="dashed", color="red", weight=0];
942[label="gcd0Gcd'1 (primEqInt (Neg (Succ (Succ vuv40))) (fromInt (Pos Zero))) (Pos (Succ vuv41)) (Neg (Succ (Succ vuv40)))",fontsize=16,color="magenta"];942 -> 951[label="",style="dashed", color="magenta", weight=3];
942 -> 952[label="",style="dashed", color="magenta", weight=3];
943[label="vuv40",fontsize=16,color="green",shape="box"];944[label="vuv41",fontsize=16,color="green",shape="box"];732[label="gcd0Gcd'0 (Pos (Succ vuv30)) (Neg (Succ vuv29))",fontsize=16,color="black",shape="box"];732 -> 747[label="",style="solid", color="black", weight=3];
945[label="Succ vuv35",fontsize=16,color="green",shape="box"];946[label="Pos (Succ vuv36)",fontsize=16,color="green",shape="box"];733[label="primMinusNatS (Succ vuv230) vuv240",fontsize=16,color="burlywood",shape="box"];1614[label="vuv240/Succ vuv2400",fontsize=10,color="white",style="solid",shape="box"];733 -> 1614[label="",style="solid", color="burlywood", weight=9];
1614 -> 748[label="",style="solid", color="burlywood", weight=3];
1615[label="vuv240/Zero",fontsize=10,color="white",style="solid",shape="box"];733 -> 1615[label="",style="solid", color="burlywood", weight=9];
1615 -> 749[label="",style="solid", color="burlywood", weight=3];
734[label="primMinusNatS Zero vuv240",fontsize=16,color="burlywood",shape="box"];1616[label="vuv240/Succ vuv2400",fontsize=10,color="white",style="solid",shape="box"];734 -> 1616[label="",style="solid", color="burlywood", weight=9];
1616 -> 750[label="",style="solid", color="burlywood", weight=3];
1617[label="vuv240/Zero",fontsize=10,color="white",style="solid",shape="box"];734 -> 1617[label="",style="solid", color="burlywood", weight=9];
1617 -> 751[label="",style="solid", color="burlywood", weight=3];
951[label="Succ vuv40",fontsize=16,color="green",shape="box"];952[label="vuv41",fontsize=16,color="green",shape="box"];747[label="gcd0Gcd' (Neg (Succ vuv29)) (Pos (Succ vuv30) `rem` Neg (Succ vuv29))",fontsize=16,color="black",shape="box"];747 -> 760[label="",style="solid", color="black", weight=3];
748[label="primMinusNatS (Succ vuv230) (Succ vuv2400)",fontsize=16,color="black",shape="box"];748 -> 761[label="",style="solid", color="black", weight=3];
749[label="primMinusNatS (Succ vuv230) Zero",fontsize=16,color="black",shape="box"];749 -> 762[label="",style="solid", color="black", weight=3];
750[label="primMinusNatS Zero (Succ vuv2400)",fontsize=16,color="black",shape="box"];750 -> 763[label="",style="solid", color="black", weight=3];
751[label="primMinusNatS Zero Zero",fontsize=16,color="black",shape="box"];751 -> 764[label="",style="solid", color="black", weight=3];
760[label="gcd0Gcd'2 (Neg (Succ vuv29)) (Pos (Succ vuv30) `rem` Neg (Succ vuv29))",fontsize=16,color="black",shape="box"];760 -> 787[label="",style="solid", color="black", weight=3];
761 -> 716[label="",style="dashed", color="red", weight=0];
761[label="primMinusNatS vuv230 vuv2400",fontsize=16,color="magenta"];761 -> 788[label="",style="dashed", color="magenta", weight=3];
761 -> 789[label="",style="dashed", color="magenta", weight=3];
762[label="Succ vuv230",fontsize=16,color="green",shape="box"];763[label="Zero",fontsize=16,color="green",shape="box"];764[label="Zero",fontsize=16,color="green",shape="box"];787[label="gcd0Gcd'1 (Pos (Succ vuv30) `rem` Neg (Succ vuv29) == fromInt (Pos Zero)) (Neg (Succ vuv29)) (Pos (Succ vuv30) `rem` Neg (Succ vuv29))",fontsize=16,color="black",shape="box"];787 -> 805[label="",style="solid", color="black", weight=3];
788[label="vuv2400",fontsize=16,color="green",shape="box"];789[label="vuv230",fontsize=16,color="green",shape="box"];805[label="gcd0Gcd'1 (primEqInt (Pos (Succ vuv30) `rem` Neg (Succ vuv29)) (fromInt (Pos Zero))) (Neg (Succ vuv29)) (Pos (Succ vuv30) `rem` Neg (Succ vuv29))",fontsize=16,color="black",shape="box"];805 -> 816[label="",style="solid", color="black", weight=3];
816[label="gcd0Gcd'1 (primEqInt (primRemInt (Pos (Succ vuv30)) (Neg (Succ vuv29))) (fromInt (Pos Zero))) (Neg (Succ vuv29)) (primRemInt (Pos (Succ vuv30)) (Neg (Succ vuv29)))",fontsize=16,color="black",shape="box"];816 -> 864[label="",style="solid", color="black", weight=3];
864 -> 1173[label="",style="dashed", color="red", weight=0];
864[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS (Succ vuv30) (Succ vuv29))) (fromInt (Pos Zero))) (Neg (Succ vuv29)) (Pos (primModNatS (Succ vuv30) (Succ vuv29)))",fontsize=16,color="magenta"];864 -> 1174[label="",style="dashed", color="magenta", weight=3];
864 -> 1175[label="",style="dashed", color="magenta", weight=3];
864 -> 1176[label="",style="dashed", color="magenta", weight=3];
1174[label="Succ vuv30",fontsize=16,color="green",shape="box"];1175[label="Succ vuv30",fontsize=16,color="green",shape="box"];1176[label="vuv29",fontsize=16,color="green",shape="box"];1173[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS vuv64 (Succ vuv62))) (fromInt (Pos Zero))) (Neg (Succ vuv62)) (Pos (primModNatS vuv63 (Succ vuv62)))",fontsize=16,color="burlywood",shape="triangle"];1620[label="vuv64/Succ vuv640",fontsize=10,color="white",style="solid",shape="box"];1173 -> 1620[label="",style="solid", color="burlywood", weight=9];
1620 -> 1185[label="",style="solid", color="burlywood", weight=3];
1621[label="vuv64/Zero",fontsize=10,color="white",style="solid",shape="box"];1173 -> 1621[label="",style="solid", color="burlywood", weight=9];
1621 -> 1186[label="",style="solid", color="burlywood", weight=3];
1185[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS (Succ vuv640) (Succ vuv62))) (fromInt (Pos Zero))) (Neg (Succ vuv62)) (Pos (primModNatS vuv63 (Succ vuv62)))",fontsize=16,color="black",shape="box"];1185 -> 1187[label="",style="solid", color="black", weight=3];
1186[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS Zero (Succ vuv62))) (fromInt (Pos Zero))) (Neg (Succ vuv62)) (Pos (primModNatS vuv63 (Succ vuv62)))",fontsize=16,color="black",shape="box"];1186 -> 1188[label="",style="solid", color="black", weight=3];
1187[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 vuv640 vuv62 (primGEqNatS vuv640 vuv62))) (fromInt (Pos Zero))) (Neg (Succ vuv62)) (Pos (primModNatS0 vuv640 vuv62 (primGEqNatS vuv640 vuv62)))",fontsize=16,color="burlywood",shape="box"];1622[label="vuv640/Succ vuv6400",fontsize=10,color="white",style="solid",shape="box"];1187 -> 1622[label="",style="solid", color="burlywood", weight=9];
1622 -> 1189[label="",style="solid", color="burlywood", weight=3];
1623[label="vuv640/Zero",fontsize=10,color="white",style="solid",shape="box"];1187 -> 1623[label="",style="solid", color="burlywood", weight=9];
1623 -> 1190[label="",style="solid", color="burlywood", weight=3];
1188[label="gcd0Gcd'1 (primEqInt (Pos Zero) (fromInt (Pos Zero))) (Neg (Succ vuv62)) (Pos Zero)",fontsize=16,color="black",shape="box"];1188 -> 1191[label="",style="solid", color="black", weight=3];
1189[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6400) vuv62 (primGEqNatS (Succ vuv6400) vuv62))) (fromInt (Pos Zero))) (Neg (Succ vuv62)) (Pos (primModNatS0 (Succ vuv6400) vuv62 (primGEqNatS (Succ vuv6400) vuv62)))",fontsize=16,color="burlywood",shape="box"];1624[label="vuv62/Succ vuv620",fontsize=10,color="white",style="solid",shape="box"];1189 -> 1624[label="",style="solid", color="burlywood", weight=9];
1624 -> 1192[label="",style="solid", color="burlywood", weight=3];
1625[label="vuv62/Zero",fontsize=10,color="white",style="solid",shape="box"];1189 -> 1625[label="",style="solid", color="burlywood", weight=9];
1625 -> 1193[label="",style="solid", color="burlywood", weight=3];
1190[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero vuv62 (primGEqNatS Zero vuv62))) (fromInt (Pos Zero))) (Neg (Succ vuv62)) (Pos (primModNatS0 Zero vuv62 (primGEqNatS Zero vuv62)))",fontsize=16,color="burlywood",shape="box"];1626[label="vuv62/Succ vuv620",fontsize=10,color="white",style="solid",shape="box"];1190 -> 1626[label="",style="solid", color="burlywood", weight=9];
1626 -> 1194[label="",style="solid", color="burlywood", weight=3];
1627[label="vuv62/Zero",fontsize=10,color="white",style="solid",shape="box"];1190 -> 1627[label="",style="solid", color="burlywood", weight=9];
1627 -> 1195[label="",style="solid", color="burlywood", weight=3];
1191[label="gcd0Gcd'1 (primEqInt (Pos Zero) (Pos Zero)) (Neg (Succ vuv62)) (Pos Zero)",fontsize=16,color="black",shape="box"];1191 -> 1196[label="",style="solid", color="black", weight=3];
1192[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6400) (Succ vuv620) (primGEqNatS (Succ vuv6400) (Succ vuv620)))) (fromInt (Pos Zero))) (Neg (Succ (Succ vuv620))) (Pos (primModNatS0 (Succ vuv6400) (Succ vuv620) (primGEqNatS (Succ vuv6400) (Succ vuv620))))",fontsize=16,color="black",shape="box"];1192 -> 1197[label="",style="solid", color="black", weight=3];
1193[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6400) Zero (primGEqNatS (Succ vuv6400) Zero))) (fromInt (Pos Zero))) (Neg (Succ Zero)) (Pos (primModNatS0 (Succ vuv6400) Zero (primGEqNatS (Succ vuv6400) Zero)))",fontsize=16,color="black",shape="box"];1193 -> 1198[label="",style="solid", color="black", weight=3];
1194[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero (Succ vuv620) (primGEqNatS Zero (Succ vuv620)))) (fromInt (Pos Zero))) (Neg (Succ (Succ vuv620))) (Pos (primModNatS0 Zero (Succ vuv620) (primGEqNatS Zero (Succ vuv620))))",fontsize=16,color="black",shape="box"];1194 -> 1199[label="",style="solid", color="black", weight=3];
1195[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero Zero (primGEqNatS Zero Zero))) (fromInt (Pos Zero))) (Neg (Succ Zero)) (Pos (primModNatS0 Zero Zero (primGEqNatS Zero Zero)))",fontsize=16,color="black",shape="box"];1195 -> 1200[label="",style="solid", color="black", weight=3];
1196[label="gcd0Gcd'1 True (Neg (Succ vuv62)) (Pos Zero)",fontsize=16,color="black",shape="box"];1196 -> 1201[label="",style="solid", color="black", weight=3];
1197 -> 1449[label="",style="dashed", color="red", weight=0];
1197[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6400) (Succ vuv620) (primGEqNatS vuv6400 vuv620))) (fromInt (Pos Zero))) (Neg (Succ (Succ vuv620))) (Pos (primModNatS0 (Succ vuv6400) (Succ vuv620) (primGEqNatS vuv6400 vuv620)))",fontsize=16,color="magenta"];1197 -> 1450[label="",style="dashed", color="magenta", weight=3];
1197 -> 1451[label="",style="dashed", color="magenta", weight=3];
1197 -> 1452[label="",style="dashed", color="magenta", weight=3];
1197 -> 1453[label="",style="dashed", color="magenta", weight=3];
1198 -> 1357[label="",style="dashed", color="red", weight=0];
1198[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv6400) Zero True)) (fromInt (Pos Zero))) (Neg (Succ Zero)) (Pos (primModNatS0 (Succ vuv6400) Zero True))",fontsize=16,color="magenta"];1198 -> 1358[label="",style="dashed", color="magenta", weight=3];
1198 -> 1359[label="",style="dashed", color="magenta", weight=3];
1199[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero (Succ vuv620) False)) (fromInt (Pos Zero))) (Neg (Succ (Succ vuv620))) (Pos (primModNatS0 Zero (Succ vuv620) False))",fontsize=16,color="black",shape="box"];1199 -> 1205[label="",style="solid", color="black", weight=3];
1200[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 Zero Zero True)) (fromInt (Pos Zero))) (Neg (Succ Zero)) (Pos (primModNatS0 Zero Zero True))",fontsize=16,color="black",shape="box"];1200 -> 1206[label="",style="solid", color="black", weight=3];
1201[label="Neg (Succ vuv62)",fontsize=16,color="green",shape="box"];1450[label="vuv6400",fontsize=16,color="green",shape="box"];1451[label="vuv6400",fontsize=16,color="green",shape="box"];1452[label="Succ vuv620",fontsize=16,color="green",shape="box"];1453[label="vuv620",fontsize=16,color="green",shape="box"];1449[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS vuv80 vuv81))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS vuv80 vuv81)))",fontsize=16,color="burlywood",shape="triangle"];1630[label="vuv80/Succ vuv800",fontsize=10,color="white",style="solid",shape="box"];1449 -> 1630[label="",style="solid", color="burlywood", weight=9];
1630 -> 1490[label="",style="solid", color="burlywood", weight=3];
1631[label="vuv80/Zero",fontsize=10,color="white",style="solid",shape="box"];1449 -> 1631[label="",style="solid", color="burlywood", weight=9];
1631 -> 1491[label="",style="solid", color="burlywood", weight=3];
1358[label="Zero",fontsize=16,color="green",shape="box"];1359[label="vuv6400",fontsize=16,color="green",shape="box"];1357[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv72) vuv73 True)) (fromInt (Pos Zero))) (Neg (Succ vuv73)) (Pos (primModNatS0 (Succ vuv72) vuv73 True))",fontsize=16,color="black",shape="triangle"];1357 -> 1380[label="",style="solid", color="black", weight=3];
1205 -> 232[label="",style="dashed", color="red", weight=0];
1205[label="gcd0Gcd'1 (primEqInt (Pos (Succ Zero)) (fromInt (Pos Zero))) (Neg (Succ (Succ vuv620))) (Pos (Succ Zero))",fontsize=16,color="magenta"];1205 -> 1214[label="",style="dashed", color="magenta", weight=3];
1205 -> 1215[label="",style="dashed", color="magenta", weight=3];
1206 -> 1173[label="",style="dashed", color="red", weight=0];
1206[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS (primMinusNatS Zero Zero) (Succ Zero))) (fromInt (Pos Zero))) (Neg (Succ Zero)) (Pos (primModNatS (primMinusNatS Zero Zero) (Succ Zero)))",fontsize=16,color="magenta"];1206 -> 1216[label="",style="dashed", color="magenta", weight=3];
1206 -> 1217[label="",style="dashed", color="magenta", weight=3];
1206 -> 1218[label="",style="dashed", color="magenta", weight=3];
1490[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS (Succ vuv800) vuv81))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS (Succ vuv800) vuv81)))",fontsize=16,color="burlywood",shape="box"];1634[label="vuv81/Succ vuv810",fontsize=10,color="white",style="solid",shape="box"];1490 -> 1634[label="",style="solid", color="burlywood", weight=9];
1634 -> 1492[label="",style="solid", color="burlywood", weight=3];
1635[label="vuv81/Zero",fontsize=10,color="white",style="solid",shape="box"];1490 -> 1635[label="",style="solid", color="burlywood", weight=9];
1635 -> 1493[label="",style="solid", color="burlywood", weight=3];
1491[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS Zero vuv81))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS Zero vuv81)))",fontsize=16,color="burlywood",shape="box"];1636[label="vuv81/Succ vuv810",fontsize=10,color="white",style="solid",shape="box"];1491 -> 1636[label="",style="solid", color="burlywood", weight=9];
1636 -> 1494[label="",style="solid", color="burlywood", weight=3];
1637[label="vuv81/Zero",fontsize=10,color="white",style="solid",shape="box"];1491 -> 1637[label="",style="solid", color="burlywood", weight=9];
1637 -> 1495[label="",style="solid", color="burlywood", weight=3];
1380 -> 1173[label="",style="dashed", color="red", weight=0];
1380[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS (primMinusNatS (Succ vuv72) vuv73) (Succ vuv73))) (fromInt (Pos Zero))) (Neg (Succ vuv73)) (Pos (primModNatS (primMinusNatS (Succ vuv72) vuv73) (Succ vuv73)))",fontsize=16,color="magenta"];1380 -> 1387[label="",style="dashed", color="magenta", weight=3];
1380 -> 1388[label="",style="dashed", color="magenta", weight=3];
1380 -> 1389[label="",style="dashed", color="magenta", weight=3];
1214[label="Zero",fontsize=16,color="green",shape="box"];1215[label="Neg (Succ (Succ vuv620))",fontsize=16,color="green",shape="box"];1216 -> 716[label="",style="dashed", color="red", weight=0];
1216[label="primMinusNatS Zero Zero",fontsize=16,color="magenta"];1216 -> 1227[label="",style="dashed", color="magenta", weight=3];
1216 -> 1228[label="",style="dashed", color="magenta", weight=3];
1217 -> 716[label="",style="dashed", color="red", weight=0];
1217[label="primMinusNatS Zero Zero",fontsize=16,color="magenta"];1217 -> 1229[label="",style="dashed", color="magenta", weight=3];
1217 -> 1230[label="",style="dashed", color="magenta", weight=3];
1218[label="Zero",fontsize=16,color="green",shape="box"];1492[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS (Succ vuv800) (Succ vuv810)))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS (Succ vuv800) (Succ vuv810))))",fontsize=16,color="black",shape="box"];1492 -> 1496[label="",style="solid", color="black", weight=3];
1493[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS (Succ vuv800) Zero))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS (Succ vuv800) Zero)))",fontsize=16,color="black",shape="box"];1493 -> 1497[label="",style="solid", color="black", weight=3];
1494[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS Zero (Succ vuv810)))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS Zero (Succ vuv810))))",fontsize=16,color="black",shape="box"];1494 -> 1498[label="",style="solid", color="black", weight=3];
1495[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS Zero Zero))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS Zero Zero)))",fontsize=16,color="black",shape="box"];1495 -> 1499[label="",style="solid", color="black", weight=3];
1387 -> 716[label="",style="dashed", color="red", weight=0];
1387[label="primMinusNatS (Succ vuv72) vuv73",fontsize=16,color="magenta"];1387 -> 1394[label="",style="dashed", color="magenta", weight=3];
1387 -> 1395[label="",style="dashed", color="magenta", weight=3];
1388 -> 716[label="",style="dashed", color="red", weight=0];
1388[label="primMinusNatS (Succ vuv72) vuv73",fontsize=16,color="magenta"];1388 -> 1396[label="",style="dashed", color="magenta", weight=3];
1388 -> 1397[label="",style="dashed", color="magenta", weight=3];
1389[label="vuv73",fontsize=16,color="green",shape="box"];1227[label="Zero",fontsize=16,color="green",shape="box"];1228[label="Zero",fontsize=16,color="green",shape="box"];1229[label="Zero",fontsize=16,color="green",shape="box"];1230[label="Zero",fontsize=16,color="green",shape="box"];1496 -> 1449[label="",style="dashed", color="red", weight=0];
1496[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS vuv800 vuv810))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 (primGEqNatS vuv800 vuv810)))",fontsize=16,color="magenta"];1496 -> 1500[label="",style="dashed", color="magenta", weight=3];
1496 -> 1501[label="",style="dashed", color="magenta", weight=3];
1497 -> 1357[label="",style="dashed", color="red", weight=0];
1497[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 True)) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 True))",fontsize=16,color="magenta"];1497 -> 1502[label="",style="dashed", color="magenta", weight=3];
1497 -> 1503[label="",style="dashed", color="magenta", weight=3];
1498[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 False)) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 False))",fontsize=16,color="black",shape="box"];1498 -> 1504[label="",style="solid", color="black", weight=3];
1499 -> 1357[label="",style="dashed", color="red", weight=0];
1499[label="gcd0Gcd'1 (primEqInt (Pos (primModNatS0 (Succ vuv78) vuv79 True)) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (primModNatS0 (Succ vuv78) vuv79 True))",fontsize=16,color="magenta"];1499 -> 1505[label="",style="dashed", color="magenta", weight=3];
1499 -> 1506[label="",style="dashed", color="magenta", weight=3];
1394[label="vuv73",fontsize=16,color="green",shape="box"];1395[label="Succ vuv72",fontsize=16,color="green",shape="box"];1396[label="vuv73",fontsize=16,color="green",shape="box"];1397[label="Succ vuv72",fontsize=16,color="green",shape="box"];1500[label="vuv800",fontsize=16,color="green",shape="box"];1501[label="vuv810",fontsize=16,color="green",shape="box"];1502[label="vuv79",fontsize=16,color="green",shape="box"];1503[label="vuv78",fontsize=16,color="green",shape="box"];1504 -> 232[label="",style="dashed", color="red", weight=0];
1504[label="gcd0Gcd'1 (primEqInt (Pos (Succ (Succ vuv78))) (fromInt (Pos Zero))) (Neg (Succ vuv79)) (Pos (Succ (Succ vuv78)))",fontsize=16,color="magenta"];1504 -> 1507[label="",style="dashed", color="magenta", weight=3];
1504 -> 1508[label="",style="dashed", color="magenta", weight=3];
1505[label="vuv79",fontsize=16,color="green",shape="box"];1506[label="vuv78",fontsize=16,color="green",shape="box"];1507[label="Succ vuv78",fontsize=16,color="green",shape="box"];1508[label="Neg (Succ vuv79)",fontsize=16,color="green",shape="box"];}

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                            ↳ QDPSizeChangeProof

                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMinusNatS(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS(vuv230, vuv2400)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

new_primMinusNatS(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS(vuv230, vuv2400)
The graph contains the following edges 1 > 1, 2 > 2

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'1(Succ(Zero), Zero) → new_gcd0Gcd'1(new_primMinusNatS0, Zero)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'11(vuv23, vuv24) → new_gcd0Gcd'1(new_primMinusNatS1(vuv23, vuv24), vuv24)
new_gcd0Gcd'0(Pos(Succ(Zero)), Zero) → new_gcd0Gcd'1(new_primMinusNatS0, Zero)
new_gcd0Gcd'17(Succ(Zero), Zero, vuv63) → new_gcd0Gcd'17(new_primMinusNatS2(Zero, Zero), Zero, new_primMinusNatS2(Zero, Zero))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Zero)), Zero) → new_gcd0Gcd'16(new_primMinusNatS0, Zero)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'16(Succ(Zero), Zero) → new_gcd0Gcd'16(new_primMinusNatS0, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'14(vuv26, vuv27) → new_gcd0Gcd'16(new_primMinusNatS1(vuv26, vuv27), vuv27)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS0 → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS0
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'11(vuv23, vuv24) → new_gcd0Gcd'1(new_primMinusNatS1(vuv23, vuv24), vuv24)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'14(vuv26, vuv27) → new_gcd0Gcd'16(new_primMinusNatS1(vuv26, vuv27), vuv27)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS0 → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS0
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'11(vuv23, vuv24) → new_gcd0Gcd'1(new_primMinusNatS1(vuv23, vuv24), vuv24)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'14(vuv26, vuv27) → new_gcd0Gcd'16(new_primMinusNatS1(vuv26, vuv27), vuv27)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS0
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS0

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'11(vuv23, vuv24) → new_gcd0Gcd'1(new_primMinusNatS1(vuv23, vuv24), vuv24)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'14(vuv26, vuv27) → new_gcd0Gcd'16(new_primMinusNatS1(vuv26, vuv27), vuv27)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule new_gcd0Gcd'11(vuv23, vuv24) → new_gcd0Gcd'1(new_primMinusNatS1(vuv23, vuv24), vuv24) at position [0] we obtained the following new rules:

new_gcd0Gcd'11(x0, Zero) → new_gcd0Gcd'1(Succ(x0), Zero)
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'11(x0, Zero) → new_gcd0Gcd'1(Succ(x0), Zero)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'14(vuv26, vuv27) → new_gcd0Gcd'16(new_primMinusNatS1(vuv26, vuv27), vuv27)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                  ↳ UsableRulesProof

                                                ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'11(x0, Zero) → new_gcd0Gcd'1(Succ(x0), Zero)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                  ↳ UsableRulesProof

                                                    ↳ QDP

                                                      ↳ QReductionProof

                                                ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'11(x0, Zero) → new_gcd0Gcd'1(Succ(x0), Zero)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                  ↳ UsableRulesProof

                                                    ↳ QDP

                                                      ↳ QReductionProof

                                                        ↳ QDP

                                                          ↳ RuleRemovalProof

                                                ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'11(x0, Zero) → new_gcd0Gcd'1(Succ(x0), Zero)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_gcd0Gcd'1(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'11(vuv6000, Zero)
new_gcd0Gcd'11(x0, Zero) → new_gcd0Gcd'1(Succ(x0), Zero)

Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x₁)) = 1 + 2·x₁
POL(Zero) = 0
POL(new_gcd0Gcd'1(x₁, x₂)) = x₁ + x₂
POL(new_gcd0Gcd'11(x₁, x₂)) = 2 + 2·x₁ + x₂

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                  ↳ UsableRulesProof

                                                    ↳ QDP

                                                      ↳ QReductionProof

                                                        ↳ QDP

                                                          ↳ RuleRemovalProof

                                                            ↳ QDP

                                                              ↳ PisEmptyProof

                                                ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'14(vuv26, vuv27) → new_gcd0Gcd'16(new_primMinusNatS1(vuv26, vuv27), vuv27)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule new_gcd0Gcd'14(vuv26, vuv27) → new_gcd0Gcd'16(new_primMinusNatS1(vuv26, vuv27), vuv27) at position [0] we obtained the following new rules:

new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'14(x0, Zero) → new_gcd0Gcd'16(Succ(x0), Zero)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'14(x0, Zero) → new_gcd0Gcd'16(Succ(x0), Zero)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'14(x0, Zero) → new_gcd0Gcd'16(Succ(x0), Zero)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)
new_gcd0Gcd'14(x0, Zero) → new_gcd0Gcd'16(Succ(x0), Zero)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ RuleRemovalProof

                                                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'14(x0, Zero) → new_gcd0Gcd'16(Succ(x0), Zero)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)

new_gcd0Gcd'16(Succ(Succ(vuv6000)), Zero) → new_gcd0Gcd'14(vuv6000, Zero)

Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x₁)) = 1 + x₁
POL(Zero) = 1
POL(new_gcd0Gcd'14(x₁, x₂)) = 2 + 2·x₁ + 2·x₂
POL(new_gcd0Gcd'16(x₁, x₂)) = 1 + 2·x₁ + x₂

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ RuleRemovalProof

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'14(x0, Zero) → new_gcd0Gcd'16(Succ(x0), Zero)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 1 less node.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS1(vuv23, Zero) → Succ(vuv23)
new_primMinusNatS1(vuv23, Succ(vuv240)) → new_primMinusNatS2(vuv23, vuv240)
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS1(x0, Zero)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS1(x0, Succ(x1))
new_primMinusNatS1(x0, Zero)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_gcd0Gcd'12(vuv400, vuv5) → new_gcd0Gcd'0(vuv5, vuv400) we obtained the following new rules:

new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'12(Zero, Neg(Succ(Succ(z0)))) → new_gcd0Gcd'0(Neg(Succ(Succ(z0))), Zero)
new_gcd0Gcd'12(Zero, Pos(Succ(Succ(z0)))) → new_gcd0Gcd'0(Pos(Succ(Succ(z0))), Zero)
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Zero, Pos(Succ(Succ(z0)))) → new_gcd0Gcd'0(Pos(Succ(Succ(z0))), Zero)
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Zero), Succ(vuv620), vuv63) → new_gcd0Gcd'12(Zero, Neg(Succ(Succ(vuv620))))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'0(Pos(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'12(Zero, Neg(Succ(Succ(z0)))) → new_gcd0Gcd'0(Neg(Succ(Succ(z0))), Zero)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'1(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'12(Zero, Pos(Succ(Succ(vuv4000))))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 5 less nodes.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                            ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

new_gcd0Gcd'1(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The remaining pairs can at least be oriented weakly.

new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)

Used ordering: Matrix interpretation [3]:
Non-tuple symbols:

M( Succ(x₁) ) =

/	0	\
\	1	/

/	1	1	\
\	0	0	/

x₁

M( new_primMinusNatS2(x₁, x₂) ) =

/	0	\
\	1	/

/	1	0	\
\	0	0	/

x₁

/	0	0	\
\	0	0	/

x₂

M( Zero ) =

/	0	\
\	0	/

M( Pos(x₁) ) =

/	0	\
\	0	/

/	0	0	\
\	1	0	/

x₁

Tuple symbols:

M( new_gcd0Gcd'0(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'10(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'11(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'1(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'12(x₁, x₂) ) =

[

]

x₁

[

]

x₂

Matrix type:
We used a basic matrix type which is not further parametrizeable.

As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)
new_primMinusNatS2(Zero, Zero) → Zero

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                            ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'11(x0, Succ(x1)) → new_gcd0Gcd'1(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Zero) → new_gcd0Gcd'11(vuv35, vuv36)
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ UsableRulesProof

                                                                            ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ UsableRulesProof

                                                                                        ↳ QDP

                                                                                          ↳ QReductionProof

                                                                            ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ UsableRulesProof

                                                                                        ↳ QDP

                                                                                          ↳ QReductionProof

                                                                                            ↳ QDP

                                                                                              ↳ NonInfProof

                                                                            ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.

For Pair new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0)) the following chains were created:

We consider the chain new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36))), new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0)) which results in the following constraint:
(1) (new_gcd0Gcd'12(Succ(x2), Pos(Succ(x3)))=new_gcd0Gcd'12(Succ(x5), Pos(Succ(x6))) ⇒ new_gcd0Gcd'12(Succ(x5), Pos(Succ(x6)))≥new_gcd0Gcd'0(Pos(Succ(x6)), Succ(x5)))

We simplified constraint (1) using rules (I), (II), (III) which results in the following new constraint:
(2) (new_gcd0Gcd'12(Succ(x2), Pos(Succ(x3)))≥new_gcd0Gcd'0(Pos(Succ(x3)), Succ(x2)))

For Pair new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36))) the following chains were created:

We consider the chain new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000), new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36))) which results in the following constraint:
(3) (new_gcd0Gcd'10(x18, Succ(x19), x18, x19)=new_gcd0Gcd'10(x20, x21, Zero, Succ(x22)) ⇒ new_gcd0Gcd'10(x20, x21, Zero, Succ(x22))≥new_gcd0Gcd'12(Succ(x20), Pos(Succ(x21))))

We simplified constraint (3) using rules (I), (II), (III) which results in the following new constraint:
(4) (new_gcd0Gcd'10(Zero, Succ(Succ(x22)), Zero, Succ(x22))≥new_gcd0Gcd'12(Succ(Zero), Pos(Succ(Succ(Succ(x22))))))
We consider the chain new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380), new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36))) which results in the following constraint:
(5) (new_gcd0Gcd'10(x23, x24, x25, x26)=new_gcd0Gcd'10(x27, x28, Zero, Succ(x29)) ⇒ new_gcd0Gcd'10(x27, x28, Zero, Succ(x29))≥new_gcd0Gcd'12(Succ(x27), Pos(Succ(x28))))

We simplified constraint (5) using rules (I), (II), (III) which results in the following new constraint:
(6) (new_gcd0Gcd'10(x23, x24, Zero, Succ(x29))≥new_gcd0Gcd'12(Succ(x23), Pos(Succ(x24))))

For Pair new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000) the following chains were created:

We consider the chain new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0)), new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000) which results in the following constraint:
(7) (new_gcd0Gcd'0(Pos(Succ(x31)), Succ(x30))=new_gcd0Gcd'0(Pos(Succ(Succ(x32))), Succ(x33)) ⇒ new_gcd0Gcd'0(Pos(Succ(Succ(x32))), Succ(x33))≥new_gcd0Gcd'10(x32, Succ(x33), x32, x33))

We simplified constraint (7) using rules (I), (II), (III) which results in the following new constraint:
(8) (new_gcd0Gcd'0(Pos(Succ(Succ(x32))), Succ(x30))≥new_gcd0Gcd'10(x32, Succ(x30), x32, x30))

For Pair new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380) the following chains were created:

We consider the chain new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000), new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380) which results in the following constraint:
(9) (new_gcd0Gcd'10(x48, Succ(x49), x48, x49)=new_gcd0Gcd'10(x50, x51, Succ(x52), Succ(x53)) ⇒ new_gcd0Gcd'10(x50, x51, Succ(x52), Succ(x53))≥new_gcd0Gcd'10(x50, x51, x52, x53))

We simplified constraint (9) using rules (I), (II), (III) which results in the following new constraint:
(10) (new_gcd0Gcd'10(Succ(x52), Succ(Succ(x53)), Succ(x52), Succ(x53))≥new_gcd0Gcd'10(Succ(x52), Succ(Succ(x53)), x52, x53))
We consider the chain new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380), new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380) which results in the following constraint:
(11) (new_gcd0Gcd'10(x54, x55, x56, x57)=new_gcd0Gcd'10(x58, x59, Succ(x60), Succ(x61)) ⇒ new_gcd0Gcd'10(x58, x59, Succ(x60), Succ(x61))≥new_gcd0Gcd'10(x58, x59, x60, x61))

We simplified constraint (11) using rules (I), (II), (III) which results in the following new constraint:
(12) (new_gcd0Gcd'10(x54, x55, Succ(x60), Succ(x61))≥new_gcd0Gcd'10(x54, x55, x60, x61))

To summarize, we get the following constraints P_≥ for the following pairs.

new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
- (new_gcd0Gcd'12(Succ(x2), Pos(Succ(x3)))≥new_gcd0Gcd'0(Pos(Succ(x3)), Succ(x2)))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
- (new_gcd0Gcd'10(Zero, Succ(Succ(x22)), Zero, Succ(x22))≥new_gcd0Gcd'12(Succ(Zero), Pos(Succ(Succ(Succ(x22))))))
- (new_gcd0Gcd'10(x23, x24, Zero, Succ(x29))≥new_gcd0Gcd'12(Succ(x23), Pos(Succ(x24))))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
- (new_gcd0Gcd'0(Pos(Succ(Succ(x32))), Succ(x30))≥new_gcd0Gcd'10(x32, Succ(x30), x32, x30))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
- (new_gcd0Gcd'10(Succ(x52), Succ(Succ(x53)), Succ(x52), Succ(x53))≥new_gcd0Gcd'10(Succ(x52), Succ(Succ(x53)), x52, x53))
- (new_gcd0Gcd'10(x54, x55, Succ(x60), Succ(x61))≥new_gcd0Gcd'10(x54, x55, x60, x61))

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation [18]:

POL(Pos(x₁)) = 0
POL(Succ(x₁)) = 1 + x₁
POL(Zero) = 0
POL(c) = -1
POL(new_gcd0Gcd'0(x₁, x₂)) = 1 - x₁ + x₂
POL(new_gcd0Gcd'10(x₁, x₂, x₃, x₄)) = 1 + x₁ - x₃ + x₄
POL(new_gcd0Gcd'12(x₁, x₂)) = 1 + x₁ - x₂

The following pairs are in P_>:

new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

The following pairs are in P_bound:

new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'0(Pos(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'10(vuv6000, Succ(vuv4000), vuv6000, vuv4000)

There are no usable rules

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ UsableRulesProof

                                                                                        ↳ QDP

                                                                                          ↳ QReductionProof

                                                                                            ↳ QDP

                                                                                              ↳ NonInfProof

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                            ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'12(Succ(z0), Pos(Succ(z1))) → new_gcd0Gcd'0(Pos(Succ(z1)), Succ(z0))
new_gcd0Gcd'10(vuv35, vuv36, Zero, Succ(vuv380)) → new_gcd0Gcd'12(Succ(vuv35), Pos(Succ(vuv36)))
new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ UsableRulesProof

                                                                                        ↳ QDP

                                                                                          ↳ QReductionProof

                                                                                            ↳ QDP

                                                                                              ↳ NonInfProof

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPSizeChangeProof

                                                                            ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)

From the DPs we obtained the following set of size-change graphs:

new_gcd0Gcd'10(vuv35, vuv36, Succ(vuv370), Succ(vuv380)) → new_gcd0Gcd'10(vuv35, vuv36, vuv370, vuv380)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3, 4 > 4

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

new_gcd0Gcd'0(Neg(Succ(Zero)), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))

The remaining pairs can at least be oriented weakly.

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)

Used ordering: Matrix interpretation [3]:
Non-tuple symbols:

M( Neg(x₁) ) =

/	0	\
\	0	/

/	0	0	\
\	0	1	/

x₁

M( Succ(x₁) ) =

/	0	\
\	0	/

/	0	0	\
\	1	0	/

x₁

M( new_primMinusNatS2(x₁, x₂) ) =

/	0	\
\	0	/

/	0	0	\
\	0	0	/

x₁

/	0	0	\
\	0	0	/

x₂

M( Zero ) =

/	1	\
\	0	/

Tuple symbols:

M( new_gcd0Gcd'0(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'16(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'18(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'13(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'12(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'15(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'19(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'14(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'17(x₁, ..., x₃) ) =

[

]

x₁

[

]

x₂

[

]

x₃

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

new_gcd0Gcd'16(Succ(Zero), Succ(vuv4000)) → new_gcd0Gcd'15(Zero, Succ(vuv4000))

The remaining pairs can at least be oriented weakly.

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)

Used ordering: Matrix interpretation [3]:
Non-tuple symbols:

M( Neg(x₁) ) =

/	0	\
\	0	/

/	1	0	\
\	0	0	/

x₁

M( Succ(x₁) ) =

/	0	\
\	0	/

/	1	1	\
\	0	0	/

x₁

M( new_primMinusNatS2(x₁, x₂) ) =

/	0	\
\	1	/

/	1	0	\
\	0	0	/

x₁

/	0	0	\
\	0	0	/

x₂

M( Zero ) =

/	1	\
\	1	/

Tuple symbols:

M( new_gcd0Gcd'0(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'16(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'18(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'13(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'12(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'15(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'19(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'14(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'17(x₁, ..., x₃) ) =

[

]

x₁

[

]

x₂

[

]

x₃

new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)
new_primMinusNatS2(Zero, Zero) → Zero

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

new_gcd0Gcd'17(Succ(Succ(vuv6400)), Zero, vuv63) → new_gcd0Gcd'19(vuv6400, Zero)

The remaining pairs can at least be oriented weakly.

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)

Used ordering: Matrix interpretation [3]:
Non-tuple symbols:

M( Neg(x₁) ) =

/	0	\
\	0	/

/	1	0	\
\	0	0	/

x₁

M( Succ(x₁) ) =

/	0	\
\	1	/

/	1	1	\
\	0	0	/

x₁

M( new_primMinusNatS2(x₁, x₂) ) =

/	0	\
\	0	/

/	1	0	\
\	0	0	/

x₁

/	0	0	\
\	1	0	/

x₂

M( Zero ) =

/	1	\
\	0	/

Tuple symbols:

M( new_gcd0Gcd'0(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'16(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'18(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'13(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'12(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'15(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'19(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'14(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'17(x₁, ..., x₃) ) =

[

]

x₁

[

]

x₂

[

]

x₃

new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)
new_primMinusNatS2(Zero, Zero) → Zero

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

new_gcd0Gcd'13(vuv40, vuv41, Zero, Zero) → new_gcd0Gcd'14(vuv40, vuv41)
new_gcd0Gcd'14(x0, Succ(x1)) → new_gcd0Gcd'16(new_primMinusNatS2(x0, x1), Succ(x1))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Zero) → new_gcd0Gcd'14(vuv40, vuv41)

The remaining pairs can at least be oriented weakly.

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)

Used ordering: Matrix interpretation [3]:
Non-tuple symbols:

M( Neg(x₁) ) =

/	1	\
\	0	/

/	1	0	\
\	1	0	/

x₁

M( Succ(x₁) ) =

/	0	\
\	1	/

/	0	1	\
\	0	1	/

x₁

M( new_primMinusNatS2(x₁, x₂) ) =

/	0	\
\	0	/

/	0	1	\
\	0	1	/

x₁

/	0	0	\
\	0	0	/

x₂

M( Zero ) =

/	0	\
\	0	/

Tuple symbols:

M( new_gcd0Gcd'0(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'16(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'18(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'13(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'12(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'15(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'19(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'14(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'17(x₁, ..., x₃) ) =

[

]

x₁

[

]

x₂

[

]

x₃

new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)
new_primMinusNatS2(Zero, Zero) → Zero

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'16(Succ(Succ(vuv6000)), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Zero) → new_gcd0Gcd'19(vuv78, vuv79)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Zero) → new_gcd0Gcd'19(vuv78, vuv79)

The remaining pairs can at least be oriented weakly.

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

Used ordering: Matrix interpretation [3]:
Non-tuple symbols:

M( Neg(x₁) ) =

/	0	\
\	0	/

/	0	0	\
\	0	0	/

x₁

M( Succ(x₁) ) =

/	0	\
\	1	/

/	1	1	\
\	0	0	/

x₁

M( new_primMinusNatS2(x₁, x₂) ) =

/	0	\
\	1	/

/	1	0	\
\	0	0	/

x₁

/	0	0	\
\	0	0	/

x₂

M( Zero ) =

/	0	\
\	0	/

Tuple symbols:

M( new_gcd0Gcd'0(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'18(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'13(x₁, ..., x₄) ) =

[

]

x₁

[

]

x₂

[

]

x₃

[

]

x₄

M( new_gcd0Gcd'12(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'15(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'19(x₁, x₂) ) =

[

]

x₁

[

]

x₂

M( new_gcd0Gcd'17(x₁, ..., x₃) ) =

[

]

x₁

[

]

x₂

[

]

x₃

new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)
new_primMinusNatS2(Zero, Zero) → Zero

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'19(vuv72, vuv73) → new_gcd0Gcd'17(new_primMinusNatS2(Succ(vuv72), vuv73), vuv73, new_primMinusNatS2(Succ(vuv72), vuv73))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(vuv230), Succ(vuv2400)) → new_primMinusNatS2(vuv230, vuv2400)
new_primMinusNatS2(Zero, Succ(vuv2400)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(vuv230), Zero) → Succ(vuv230)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_gcd0Gcd'17(Succ(Succ(vuv6400)), Succ(vuv620), vuv63) → new_gcd0Gcd'18(vuv6400, Succ(vuv620), vuv6400, vuv620) we obtained the following new rules:

new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1)

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ NonInfProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.

For Pair new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79))) the following chains were created:

We consider the chain new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810), new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79))) which results in the following constraint:
(1) (new_gcd0Gcd'18(x16, x17, x18, x19)=new_gcd0Gcd'18(x20, x21, Zero, Succ(x22)) ⇒ new_gcd0Gcd'18(x20, x21, Zero, Succ(x22))≥new_gcd0Gcd'12(Succ(x20), Neg(Succ(x21))))

We simplified constraint (1) using rules (I), (II), (III) which results in the following new constraint:
(2) (new_gcd0Gcd'18(x16, x17, Zero, Succ(x22))≥new_gcd0Gcd'12(Succ(x16), Neg(Succ(x17))))
We consider the chain new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1), new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79))) which results in the following constraint:
(3) (new_gcd0Gcd'18(x23, Succ(x24), x23, x24)=new_gcd0Gcd'18(x25, x26, Zero, Succ(x27)) ⇒ new_gcd0Gcd'18(x25, x26, Zero, Succ(x27))≥new_gcd0Gcd'12(Succ(x25), Neg(Succ(x26))))

We simplified constraint (3) using rules (I), (II), (III) which results in the following new constraint:
(4) (new_gcd0Gcd'18(Zero, Succ(Succ(x27)), Zero, Succ(x27))≥new_gcd0Gcd'12(Succ(Zero), Neg(Succ(Succ(Succ(x27))))))

For Pair new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000) the following chains were created:

We consider the chain new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0)), new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000) which results in the following constraint:
(5) (new_gcd0Gcd'0(Neg(Succ(x39)), Succ(x38))=new_gcd0Gcd'0(Neg(Succ(Succ(x40))), Succ(x41)) ⇒ new_gcd0Gcd'0(Neg(Succ(Succ(x40))), Succ(x41))≥new_gcd0Gcd'13(x40, Succ(x41), x40, x41))

We simplified constraint (5) using rules (I), (II), (III) which results in the following new constraint:
(6) (new_gcd0Gcd'0(Neg(Succ(Succ(x40))), Succ(x38))≥new_gcd0Gcd'13(x40, Succ(x38), x40, x38))

For Pair new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41) the following chains were created:

We consider the chain new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000), new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41) which results in the following constraint:
(7) (new_gcd0Gcd'13(x55, Succ(x56), x55, x56)=new_gcd0Gcd'13(x57, x58, Zero, Succ(x59)) ⇒ new_gcd0Gcd'13(x57, x58, Zero, Succ(x59))≥new_gcd0Gcd'15(Succ(x57), x58))

We simplified constraint (7) using rules (I), (II), (III) which results in the following new constraint:
(8) (new_gcd0Gcd'13(Zero, Succ(Succ(x59)), Zero, Succ(x59))≥new_gcd0Gcd'15(Succ(Zero), Succ(Succ(x59))))
We consider the chain new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430), new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41) which results in the following constraint:
(9) (new_gcd0Gcd'13(x67, x68, x69, x70)=new_gcd0Gcd'13(x71, x72, Zero, Succ(x73)) ⇒ new_gcd0Gcd'13(x71, x72, Zero, Succ(x73))≥new_gcd0Gcd'15(Succ(x71), x72))

We simplified constraint (9) using rules (I), (II), (III) which results in the following new constraint:
(10) (new_gcd0Gcd'13(x67, x68, Zero, Succ(x73))≥new_gcd0Gcd'15(Succ(x67), x68))

For Pair new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30)) the following chains were created:

We consider the chain new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41), new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30)) which results in the following constraint:
(11) (new_gcd0Gcd'15(Succ(x85), x86)=new_gcd0Gcd'15(x88, x89) ⇒ new_gcd0Gcd'15(x88, x89)≥new_gcd0Gcd'17(Succ(x89), x88, Succ(x89)))

We simplified constraint (11) using rules (I), (II), (III) which results in the following new constraint:
(12) (new_gcd0Gcd'15(Succ(x85), x86)≥new_gcd0Gcd'17(Succ(x86), Succ(x85), Succ(x86)))

For Pair new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0)) the following chains were created:

We consider the chain new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79))), new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0)) which results in the following constraint:
(13) (new_gcd0Gcd'12(Succ(x104), Neg(Succ(x105)))=new_gcd0Gcd'12(Succ(x107), Neg(Succ(x108))) ⇒ new_gcd0Gcd'12(Succ(x107), Neg(Succ(x108)))≥new_gcd0Gcd'0(Neg(Succ(x108)), Succ(x107)))

We simplified constraint (13) using rules (I), (II), (III) which results in the following new constraint:
(14) (new_gcd0Gcd'12(Succ(x104), Neg(Succ(x105)))≥new_gcd0Gcd'0(Neg(Succ(x105)), Succ(x104)))

For Pair new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430) the following chains were created:

We consider the chain new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000), new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430) which results in the following constraint:
(15) (new_gcd0Gcd'13(x131, Succ(x132), x131, x132)=new_gcd0Gcd'13(x133, x134, Succ(x135), Succ(x136)) ⇒ new_gcd0Gcd'13(x133, x134, Succ(x135), Succ(x136))≥new_gcd0Gcd'13(x133, x134, x135, x136))

We simplified constraint (15) using rules (I), (II), (III) which results in the following new constraint:
(16) (new_gcd0Gcd'13(Succ(x135), Succ(Succ(x136)), Succ(x135), Succ(x136))≥new_gcd0Gcd'13(Succ(x135), Succ(Succ(x136)), x135, x136))
We consider the chain new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430), new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430) which results in the following constraint:
(17) (new_gcd0Gcd'13(x144, x145, x146, x147)=new_gcd0Gcd'13(x148, x149, Succ(x150), Succ(x151)) ⇒ new_gcd0Gcd'13(x148, x149, Succ(x150), Succ(x151))≥new_gcd0Gcd'13(x148, x149, x150, x151))

We simplified constraint (17) using rules (I), (II), (III) which results in the following new constraint:
(18) (new_gcd0Gcd'13(x144, x145, Succ(x150), Succ(x151))≥new_gcd0Gcd'13(x144, x145, x150, x151))

For Pair new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810) the following chains were created:

We consider the chain new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810), new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810) which results in the following constraint:
(19) (new_gcd0Gcd'18(x174, x175, x176, x177)=new_gcd0Gcd'18(x178, x179, Succ(x180), Succ(x181)) ⇒ new_gcd0Gcd'18(x178, x179, Succ(x180), Succ(x181))≥new_gcd0Gcd'18(x178, x179, x180, x181))

We simplified constraint (19) using rules (I), (II), (III) which results in the following new constraint:
(20) (new_gcd0Gcd'18(x174, x175, Succ(x180), Succ(x181))≥new_gcd0Gcd'18(x174, x175, x180, x181))
We consider the chain new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1), new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810) which results in the following constraint:
(21) (new_gcd0Gcd'18(x182, Succ(x183), x182, x183)=new_gcd0Gcd'18(x184, x185, Succ(x186), Succ(x187)) ⇒ new_gcd0Gcd'18(x184, x185, Succ(x186), Succ(x187))≥new_gcd0Gcd'18(x184, x185, x186, x187))

We simplified constraint (21) using rules (I), (II), (III) which results in the following new constraint:
(22) (new_gcd0Gcd'18(Succ(x186), Succ(Succ(x187)), Succ(x186), Succ(x187))≥new_gcd0Gcd'18(Succ(x186), Succ(Succ(x187)), x186, x187))

For Pair new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1) the following chains were created:

We consider the chain new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30)), new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1) which results in the following constraint:
(23) (new_gcd0Gcd'17(Succ(x197), x196, Succ(x197))=new_gcd0Gcd'17(Succ(Succ(x198)), Succ(x199), Succ(Succ(x198))) ⇒ new_gcd0Gcd'17(Succ(Succ(x198)), Succ(x199), Succ(Succ(x198)))≥new_gcd0Gcd'18(x198, Succ(x199), x198, x199))

We simplified constraint (23) using rules (I), (II), (III) which results in the following new constraint:
(24) (new_gcd0Gcd'17(Succ(Succ(x198)), Succ(x199), Succ(Succ(x198)))≥new_gcd0Gcd'18(x198, Succ(x199), x198, x199))

To summarize, we get the following constraints P_≥ for the following pairs.

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
- (new_gcd0Gcd'18(x16, x17, Zero, Succ(x22))≥new_gcd0Gcd'12(Succ(x16), Neg(Succ(x17))))
- (new_gcd0Gcd'18(Zero, Succ(Succ(x27)), Zero, Succ(x27))≥new_gcd0Gcd'12(Succ(Zero), Neg(Succ(Succ(Succ(x27))))))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
- (new_gcd0Gcd'0(Neg(Succ(Succ(x40))), Succ(x38))≥new_gcd0Gcd'13(x40, Succ(x38), x40, x38))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
- (new_gcd0Gcd'13(Zero, Succ(Succ(x59)), Zero, Succ(x59))≥new_gcd0Gcd'15(Succ(Zero), Succ(Succ(x59))))
- (new_gcd0Gcd'13(x67, x68, Zero, Succ(x73))≥new_gcd0Gcd'15(Succ(x67), x68))
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
- (new_gcd0Gcd'15(Succ(x85), x86)≥new_gcd0Gcd'17(Succ(x86), Succ(x85), Succ(x86)))
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
- (new_gcd0Gcd'12(Succ(x104), Neg(Succ(x105)))≥new_gcd0Gcd'0(Neg(Succ(x105)), Succ(x104)))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
- (new_gcd0Gcd'13(Succ(x135), Succ(Succ(x136)), Succ(x135), Succ(x136))≥new_gcd0Gcd'13(Succ(x135), Succ(Succ(x136)), x135, x136))
- (new_gcd0Gcd'13(x144, x145, Succ(x150), Succ(x151))≥new_gcd0Gcd'13(x144, x145, x150, x151))
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
- (new_gcd0Gcd'18(x174, x175, Succ(x180), Succ(x181))≥new_gcd0Gcd'18(x174, x175, x180, x181))
- (new_gcd0Gcd'18(Succ(x186), Succ(Succ(x187)), Succ(x186), Succ(x187))≥new_gcd0Gcd'18(Succ(x186), Succ(Succ(x187)), x186, x187))
new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1)
- (new_gcd0Gcd'17(Succ(Succ(x198)), Succ(x199), Succ(Succ(x198)))≥new_gcd0Gcd'18(x198, Succ(x199), x198, x199))

POL(Neg(x₁)) = 0
POL(Succ(x₁)) = 1 + x₁
POL(Zero) = 0
POL(c) = -1
POL(new_gcd0Gcd'0(x₁, x₂)) = -1 - x₁
POL(new_gcd0Gcd'12(x₁, x₂)) = -1 - x₂
POL(new_gcd0Gcd'13(x₁, x₂, x₃, x₄)) = x₁ - x₂ - x₃ + x₄
POL(new_gcd0Gcd'15(x₁, x₂)) = -1 + x₁ - x₂
POL(new_gcd0Gcd'17(x₁, x₂, x₃)) = -x₁ + x₂
POL(new_gcd0Gcd'18(x₁, x₂, x₃, x₄)) = -1 - x₃ + x₄

The following pairs are in P_>:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)

The following pairs are in P_bound:

new_gcd0Gcd'18(vuv78, vuv79, Zero, Succ(vuv810)) → new_gcd0Gcd'12(Succ(vuv78), Neg(Succ(vuv79)))
new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))

There are no usable rules

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ NonInfProof

                                                                                                                        ↳ AND

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'0(Neg(Succ(Succ(vuv6000))), Succ(vuv4000)) → new_gcd0Gcd'13(vuv6000, Succ(vuv4000), vuv6000, vuv4000)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1)
new_gcd0Gcd'12(Succ(z0), Neg(Succ(z1))) → new_gcd0Gcd'0(Neg(Succ(z1)), Succ(z0))
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 4 less nodes.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ NonInfProof

                                                                                                                        ↳ AND

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ QDPSizeChangeProof

                                                                                                                                ↳ QDP

                                                                                                                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

From the DPs we obtained the following set of size-change graphs:

new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3, 4 > 4

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ NonInfProof

                                                                                                                        ↳ AND

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ QDPSizeChangeProof

                                                                                                                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)

From the DPs we obtained the following set of size-change graphs:

new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3, 4 > 4

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ NonInfProof

                                                                                                                        ↳ AND

                                                                                                                          ↳ QDP

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'13(vuv40, vuv41, Zero, Succ(vuv430)) → new_gcd0Gcd'15(Succ(vuv40), vuv41)
new_gcd0Gcd'15(vuv29, vuv30) → new_gcd0Gcd'17(Succ(vuv30), vuv29, Succ(vuv30))
new_gcd0Gcd'17(Succ(Succ(x0)), Succ(x1), Succ(Succ(x0))) → new_gcd0Gcd'18(x0, Succ(x1), x0, x1)
new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 3 less nodes.

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ NonInfProof

                                                                                                                        ↳ AND

                                                                                                                          ↳ QDP

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ QDPSizeChangeProof

                                                                                                                                ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)

From the DPs we obtained the following set of size-change graphs:

new_gcd0Gcd'18(vuv78, vuv79, Succ(vuv800), Succ(vuv810)) → new_gcd0Gcd'18(vuv78, vuv79, vuv800, vuv810)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3, 4 > 4

↳ HASKELL

  ↳ IFR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ LetRed

                ↳ HASKELL

                  ↳ NumRed

                    ↳ HASKELL

                      ↳ Narrow

                        ↳ AND

                          ↳ QDP

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ UsableRulesProof

                                  ↳ QDP

                                    ↳ QReductionProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                                                  ↳ Narrowing

                                                    ↳ QDP

                                                      ↳ DependencyGraphProof

                                                        ↳ AND

                                                          ↳ QDP

                                                          ↳ QDP

                                                            ↳ UsableRulesProof

                                                              ↳ QDP

                                                                ↳ QReductionProof

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ AND

                                                                            ↳ QDP

                                                                            ↳ QDP

                                                                              ↳ QDPOrderProof

                                                                                ↳ QDP

                                                                                  ↳ QDPOrderProof

                                                                                    ↳ QDP

                                                                                      ↳ QDPOrderProof

                                                                                        ↳ QDP

                                                                                          ↳ QDPOrderProof

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ QDPOrderProof

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ UsableRulesProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QReductionProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ NonInfProof

                                                                                                                        ↳ AND

                                                                                                                          ↳ QDP

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)

From the DPs we obtained the following set of size-change graphs:

new_gcd0Gcd'13(vuv40, vuv41, Succ(vuv420), Succ(vuv430)) → new_gcd0Gcd'13(vuv40, vuv41, vuv420, vuv430)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3, 4 > 4

primModNatS0	x y True	= primModNatS (primMinusNatS x y) (Succ y)
primModNatS0	x y False	= Succ x

gcd2	True yx yy	= gcd1 (yy == 0) yx yy
gcd2	zw zx zy	= gcd0 zx zy

gcd0Gcd'2	x xx	= gcd0Gcd'1 (xx == 0) x xx
gcd0Gcd'2	yv yw	= gcd0Gcd'0 yv yw